clang-formatted GraphicsEngineD3DBase project

15 files changed, 1766 insertions, 1698 deletions

diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h b/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h
index 81c478a3..fdc3689f 100644
--- a/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h
+++ b/Graphics/GraphicsEngineD3DBase/include/D3DErrors.h
@@ -35,64 +35,66 @@ namespace Diligent
 class ComErrorDesc
 {
 public:
-    ComErrorDesc( HRESULT hr )
+    ComErrorDesc(HRESULT hr)
     {
-        FormatMessageA( 
-            FORMAT_MESSAGE_FROM_SYSTEM |
-            FORMAT_MESSAGE_IGNORE_INSERTS,
+        FormatMessageA(
+            FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
             NULL,
             hr,
-            MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             m_Msg,
             _countof(m_Msg),
-            NULL );
-        auto nLen = strlen( m_Msg );
-        if( nLen > 1 && m_Msg[nLen - 1] == '\n' ) 
+            NULL);
+        auto nLen = strlen(m_Msg);
+        if (nLen > 1 && m_Msg[nLen - 1] == '\n')
         {
             m_Msg[nLen - 1] = 0;
-            if( m_Msg[nLen - 2] == '\r' ) 
+            if (m_Msg[nLen - 2] == '\r')
             {
                 m_Msg[nLen - 2] = 0;
             }
         }
     }
 
-    const char* Get(){ return m_Msg; }
+    const char* Get() { return m_Msg; }
 
 private:
     char m_Msg[4096];
 };
 
-}
+} // namespace Diligent
 
 
-#define CHECK_D3D_RESULT_THROW(Expr, Message)\
-do{                         \
-    HRESULT _hr_ = Expr;    \
-    if(FAILED(_hr_))        \
-    {                       \
-        ComErrorDesc ErrDesc( _hr_ );    \
-        LOG_ERROR_AND_THROW( Message, "\nHRESULT Desc: ", ErrDesc.Get());\
-    }                       \
-}while(false)
+#define CHECK_D3D_RESULT_THROW(Expr, Message)                                \
+    do                                                                       \
+    {                                                                        \
+        HRESULT _hr_ = Expr;                                                 \
+        if (FAILED(_hr_))                                                    \
+        {                                                                    \
+            ComErrorDesc ErrDesc(_hr_);                                      \
+            LOG_ERROR_AND_THROW(Message, "\nHRESULT Desc: ", ErrDesc.Get()); \
+        }                                                                    \
+    } while (false)
 
-#define CHECK_D3D_RESULT_THROW_EX(Expr, ...)\
-do{                         \
-    HRESULT _hr_ = Expr;    \
-    if(FAILED(_hr_))        \
-    {                       \
-        auto msg = Diligent::FormatString(__VA_ARGS__);  \
-        ComErrorDesc ErrDesc( _hr_ );                    \
-        LOG_ERROR_AND_THROW( msg, "\nHRESULT Desc: ", ErrDesc.Get());\
-    }                       \
-}while(false)
+#define CHECK_D3D_RESULT_THROW_EX(Expr, ...)                             \
+    do                                                                   \
+    {                                                                    \
+        HRESULT _hr_ = Expr;                                             \
+        if (FAILED(_hr_))                                                \
+        {                                                                \
+            auto         msg = Diligent::FormatString(__VA_ARGS__);      \
+            ComErrorDesc ErrDesc(_hr_);                                  \
+            LOG_ERROR_AND_THROW(msg, "\nHRESULT Desc: ", ErrDesc.Get()); \
+        }                                                                \
+    } while (false)
 
-#define LOG_D3D_ERROR(Expr, Message)\
-do{                         \
-    HRESULT _hr_ = Expr;    \
-    if(FAILED(_hr_))        \
-    {                       \
-        ComErrorDesc ErrDesc( _hr_ );    \
-        LOG_ERROR_MESSAGE( Message, "\nHRESULT Desc: ", ErrDesc.Get());\
-    }                       \
-}while(false)
+#define LOG_D3D_ERROR(Expr, Message)                                       \
+    do                                                                     \
+    {                                                                      \
+        HRESULT _hr_ = Expr;                                               \
+        if (FAILED(_hr_))                                                  \
+        {                                                                  \
+            ComErrorDesc ErrDesc(_hr_);                                    \
+            LOG_ERROR_MESSAGE(Message, "\nHRESULT Desc: ", ErrDesc.Get()); \
+        }                                                                  \
+    } while (false)
diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
index 008b41af..35562249 100644
--- a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
+++ b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
@@ -35,261 +35,268 @@
 
 namespace Diligent
 {
-    struct D3DShaderResourceCounters
-    {
-        Uint32 NumCBs      = 0;
-        Uint32 NumTexSRVs  = 0;
-        Uint32 NumTexUAVs  = 0; 
-        Uint32 NumBufSRVs  = 0;
-        Uint32 NumBufUAVs  = 0;
-        Uint32 NumSamplers = 0;
-    };
-
-    template<typename D3D_SHADER_DESC, 
-             typename D3D_SHADER_INPUT_BIND_DESC,
-             typename TShaderReflection, 
-
-             typename THandleShaderDesc,
-             typename TOnResourcesCounted,
-             typename TOnNewCB, 
-             typename TOnNewTexUAV, 
-             typename TOnNewBuffUAV, 
-             typename TOnNewBuffSRV,
-             typename TOnNewSampler,
-             typename TOnNewTexSRV>
-    void LoadD3DShaderResources(ID3DBlob*           pShaderByteCode, 
-                                THandleShaderDesc   HandleShaderDesc,
-                                TOnResourcesCounted OnResourcesCounted,
-                                TOnNewCB            OnNewCB, 
-                                TOnNewTexUAV        OnNewTexUAV, 
-                                TOnNewBuffUAV       OnNewBuffUAV, 
-                                TOnNewBuffSRV       OnNewBuffSRV,
-                                TOnNewSampler       OnNewSampler,
-                                TOnNewTexSRV        OnNewTexSRV)
+
+struct D3DShaderResourceCounters
+{
+    Uint32 NumCBs      = 0;
+    Uint32 NumTexSRVs  = 0;
+    Uint32 NumTexUAVs  = 0;
+    Uint32 NumBufSRVs  = 0;
+    Uint32 NumBufUAVs  = 0;
+    Uint32 NumSamplers = 0;
+};
+
+template <typename D3D_SHADER_DESC,
+          typename D3D_SHADER_INPUT_BIND_DESC,
+          typename TShaderReflection,
+
+          typename THandleShaderDesc,
+          typename TOnResourcesCounted,
+          typename TOnNewCB,
+          typename TOnNewTexUAV,
+          typename TOnNewBuffUAV,
+          typename TOnNewBuffSRV,
+          typename TOnNewSampler,
+          typename TOnNewTexSRV>
+void LoadD3DShaderResources(ID3DBlob*           pShaderByteCode,
+                            THandleShaderDesc   HandleShaderDesc,
+                            TOnResourcesCounted OnResourcesCounted,
+                            TOnNewCB            OnNewCB,
+                            TOnNewTexUAV        OnNewTexUAV,
+                            TOnNewBuffUAV       OnNewBuffUAV,
+                            TOnNewBuffSRV       OnNewBuffSRV,
+                            TOnNewSampler       OnNewSampler,
+                            TOnNewTexSRV        OnNewTexSRV)
+{
+    CComPtr<TShaderReflection> pShaderReflection;
+
+    auto hr = D3DReflect(pShaderByteCode->GetBufferPointer(), pShaderByteCode->GetBufferSize(), __uuidof(pShaderReflection), reinterpret_cast<void**>(static_cast<TShaderReflection**>(&pShaderReflection)));
+    CHECK_D3D_RESULT_THROW(hr, "Failed to get the shader reflection");
+
+    D3D_SHADER_DESC shaderDesc = {};
+    pShaderReflection->GetDesc(&shaderDesc);
+
+    HandleShaderDesc(shaderDesc);
+
+    std::vector<D3DShaderResourceAttribs, STDAllocatorRawMem<D3DShaderResourceAttribs>> Resources(STD_ALLOCATOR_RAW_MEM(D3DShaderResourceAttribs, GetRawAllocator(), "Allocator for vector<D3DShaderResourceAttribs>"));
+    Resources.reserve(shaderDesc.BoundResources);
+    std::unordered_set<std::string> ResourceNamesTmpPool;
+
+    D3DShaderResourceCounters RC;
+
+    size_t ResourceNamesPoolSize = 0;
+    // Number of resources to skip (used for array resources)
+    UINT SkipCount = 1;
+    for (UINT Res = 0; Res < shaderDesc.BoundResources; Res += SkipCount)
     {
-        CComPtr<TShaderReflection> pShaderReflection;
-        auto hr = D3DReflect( pShaderByteCode->GetBufferPointer(), pShaderByteCode->GetBufferSize(), __uuidof(pShaderReflection), reinterpret_cast<void**>(static_cast<TShaderReflection**>(&pShaderReflection)));
-        CHECK_D3D_RESULT_THROW(hr, "Failed to get the shader reflection" );
-
-        D3D_SHADER_DESC shaderDesc = {};
-        pShaderReflection->GetDesc( &shaderDesc );
-
-        HandleShaderDesc(shaderDesc);
-
-        std::vector<D3DShaderResourceAttribs, STDAllocatorRawMem<D3DShaderResourceAttribs> > Resources( STD_ALLOCATOR_RAW_MEM(D3DShaderResourceAttribs, GetRawAllocator(), "Allocator for vector<D3DShaderResourceAttribs>") );
-        Resources.reserve(shaderDesc.BoundResources);
-        std::unordered_set<std::string> ResourceNamesTmpPool;
-        
-        D3DShaderResourceCounters RC;
-        size_t ResourceNamesPoolSize = 0;
-        // Number of resources to skip (used for array resources)
-        UINT SkipCount = 1;
-        for (UINT Res = 0; Res < shaderDesc.BoundResources; Res += SkipCount)
+        D3D_SHADER_INPUT_BIND_DESC BindingDesc = {};
+        pShaderReflection->GetResourceBindingDesc(Res, &BindingDesc);
+
+        std::string Name(BindingDesc.Name);
+
+        SkipCount = 1;
+
+        UINT BindCount = BindingDesc.BindCount;
+
+        // Handle arrays
+        // For shader models 5_0 and before, every resource array element is enumerated individually.
+        // For instance, if the following texture array is defined in the shader:
+        //
+        //     Texture2D<float3> g_tex2DDiffuse[4];
+        //
+        // The reflection system will enumerate 4 resources with the following names:
+        // "g_tex2DDiffuse[0]"
+        // "g_tex2DDiffuse[1]"
+        // "g_tex2DDiffuse[2]"
+        // "g_tex2DDiffuse[3]"
+        //
+        // Notice that if some array element is not used by the shader, it will not be enumerated
+
+        auto OpenBracketPos = Name.find('[');
+        if (String::npos != OpenBracketPos)
         {
-            D3D_SHADER_INPUT_BIND_DESC BindingDesc = {};
-            pShaderReflection->GetResourceBindingDesc( Res, &BindingDesc );
-
-            std::string Name(BindingDesc.Name);
-            
-            SkipCount = 1;
-            
-            UINT BindCount = BindingDesc.BindCount;
-            
-            // Handle arrays
-            // For shader models 5_0 and before, every resource array element is enumerated individually.
-            // For instance, if the following texture array is defined in the shader:
-            //
-            //     Texture2D<float3> g_tex2DDiffuse[4];
-            //
-            // The reflection system will enumerate 4 resources with the following names:
-            // "g_tex2DDiffuse[0]"
-            // "g_tex2DDiffuse[1]"
-            // "g_tex2DDiffuse[2]"
-            // "g_tex2DDiffuse[3]"
-            // 
-            // Notice that if some array element is not used by the shader, it will not be enumerated
-
-            auto OpenBracketPos = Name.find('[');
-            if (String::npos != OpenBracketPos)
-            {
-                VERIFY(BindCount == 1, "When array elements are enumerated individually, BindCount is expected to always be 1");
-
-                // Name == "g_tex2DDiffuse[0]"
-                //                        ^
-                //                   OpenBracketPos
-                Name.erase(OpenBracketPos, Name.length() - OpenBracketPos);
-                // Name == "g_tex2DDiffuse"
-                VERIFY_EXPR(Name.length() == OpenBracketPos);
+            VERIFY(BindCount == 1, "When array elements are enumerated individually, BindCount is expected to always be 1");
+
+            // Name == "g_tex2DDiffuse[0]"
+            //                        ^
+            //                   OpenBracketPos
+            Name.erase(OpenBracketPos, Name.length() - OpenBracketPos);
+            // Name == "g_tex2DDiffuse"
+            VERIFY_EXPR(Name.length() == OpenBracketPos);
 #ifdef _DEBUG
-                for (const auto& ExistingRes : Resources)
+            for (const auto& ExistingRes : Resources)
+            {
+                VERIFY(Name.compare(ExistingRes.Name) != 0, "Resource with the same name has already been enumerated. All array elements are expected to be enumerated one after another");
+            }
+#endif
+            for (UINT ArrElem = Res + 1; ArrElem < shaderDesc.BoundResources; ++ArrElem)
+            {
+                D3D_SHADER_INPUT_BIND_DESC ArrElemBindingDesc = {};
+                pShaderReflection->GetResourceBindingDesc(ArrElem, &ArrElemBindingDesc);
+
+                // Make sure this case is handled correctly:
+                // "g_tex2DDiffuse[.]" != "g_tex2DDiffuse2[.]"
+                if (strncmp(Name.c_str(), ArrElemBindingDesc.Name, OpenBracketPos) == 0 && ArrElemBindingDesc.Name[OpenBracketPos] == '[')
                 {
-                    VERIFY(Name.compare(ExistingRes.Name) != 0, "Resource with the same name has already been enumerated. All array elements are expected to be enumerated one after another");
+                    //g_tex2DDiffuse[2]
+                    //               ^
+                    UINT Ind  = atoi(ArrElemBindingDesc.Name + OpenBracketPos + 1);
+                    BindCount = std::max(BindCount, Ind + 1);
+                    VERIFY(ArrElemBindingDesc.BindPoint == BindingDesc.BindPoint + Ind,
+                           "Array elements are expected to use contigous bind points.\n",
+                           BindingDesc.Name, " uses slot ", BindingDesc.BindPoint, ", so ", ArrElemBindingDesc.Name,
+                           " is expected to use slot ", BindingDesc.BindPoint + Ind, " while ", ArrElemBindingDesc.BindPoint,
+                           " is actually used");
+
+                    // Note that skip count may not necessarily be the same as BindCount.
+                    // If some array elements are not used by the shader, the reflection system skips them
+                    ++SkipCount;
                 }
-#endif
-                for (UINT ArrElem = Res+1; ArrElem < shaderDesc.BoundResources; ++ArrElem)
+                else
                 {
-                    D3D_SHADER_INPUT_BIND_DESC ArrElemBindingDesc = {};
-                    pShaderReflection->GetResourceBindingDesc( ArrElem, &ArrElemBindingDesc );
-                    
-                    // Make sure this case is handled correctly:
-                    // "g_tex2DDiffuse[.]" != "g_tex2DDiffuse2[.]"
-                    if ( strncmp(Name.c_str(), ArrElemBindingDesc.Name, OpenBracketPos) == 0 && ArrElemBindingDesc.Name[OpenBracketPos] == '[')
-                    {
-                        //g_tex2DDiffuse[2]
-                        //               ^
-                        UINT Ind = atoi(ArrElemBindingDesc.Name+OpenBracketPos+1);
-                        BindCount = std::max(BindCount, Ind+1);
-                        VERIFY(ArrElemBindingDesc.BindPoint == BindingDesc.BindPoint + Ind, 
-                               "Array elements are expected to use contigous bind points.\n", 
-                                BindingDesc.Name, " uses slot ", BindingDesc.BindPoint, ", so ", ArrElemBindingDesc.Name, " is expected to use slot ", BindingDesc.BindPoint + Ind, " while ", ArrElemBindingDesc.BindPoint, " is actually used" );
-                        
-                        // Note that skip count may not necessarily be the same as BindCount.
-                        // If some array elements are not used by the shader, the reflection system skips them
-                        ++SkipCount;
-                    }
-                    else
-                    {
-                        break;
-                    }
+                    break;
                 }
             }
+        }
 
-            switch( BindingDesc.Type )
-            {
-                case D3D_SIT_CBUFFER:                       ++RC.NumCBs;                                                                           break;
-                case D3D_SIT_TBUFFER:                       UNSUPPORTED( "TBuffers are not supported" );                                           break;
-                case D3D_SIT_TEXTURE:                       ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufSRVs : RC.NumTexSRVs); break;
-                case D3D_SIT_SAMPLER:                       ++RC.NumSamplers;                                                                      break;
-                case D3D_SIT_UAV_RWTYPED:                   ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufUAVs : RC.NumTexUAVs); break;
-                case D3D_SIT_STRUCTURED:                    ++RC.NumBufSRVs;                                                                       break;
-                case D3D_SIT_UAV_RWSTRUCTURED:              ++RC.NumBufUAVs;                                                                       break;
-                case D3D_SIT_BYTEADDRESS:                   ++RC.NumBufSRVs;                                                                       break;
-                case D3D_SIT_UAV_RWBYTEADDRESS:             ++RC.NumBufUAVs;                                                                       break;
-                case D3D_SIT_UAV_APPEND_STRUCTURED:         UNSUPPORTED( "Append structured buffers are not supported" );                          break;
-                case D3D_SIT_UAV_CONSUME_STRUCTURED:        UNSUPPORTED( "Consume structured buffers are not supported" );                         break;
-                case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" );                 break;
-                default: UNEXPECTED("Unexpected resource type");
-            }
-            ResourceNamesPoolSize += Name.length() + 1;
-            auto it = ResourceNamesTmpPool.emplace(std::move(Name));
-            Resources.emplace_back(
-                it.first->c_str(), 
-                BindingDesc.BindPoint, 
-                BindCount, 
-                BindingDesc.Type, 
-                BindingDesc.Dimension, 
-                D3DShaderResourceAttribs::InvalidSamplerId
-            );
+        switch (BindingDesc.Type)
+        {
+            // clang-format off
+            case D3D_SIT_CBUFFER:                       ++RC.NumCBs;                                                                           break;
+            case D3D_SIT_TBUFFER:                       UNSUPPORTED( "TBuffers are not supported" );                                           break;
+            case D3D_SIT_TEXTURE:                       ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufSRVs : RC.NumTexSRVs); break;
+            case D3D_SIT_SAMPLER:                       ++RC.NumSamplers;                                                                      break;
+            case D3D_SIT_UAV_RWTYPED:                   ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufUAVs : RC.NumTexUAVs); break;
+            case D3D_SIT_STRUCTURED:                    ++RC.NumBufSRVs;                                                                       break;
+            case D3D_SIT_UAV_RWSTRUCTURED:              ++RC.NumBufUAVs;                                                                       break;
+            case D3D_SIT_BYTEADDRESS:                   ++RC.NumBufSRVs;                                                                       break;
+            case D3D_SIT_UAV_RWBYTEADDRESS:             ++RC.NumBufUAVs;                                                                       break;
+            case D3D_SIT_UAV_APPEND_STRUCTURED:         UNSUPPORTED( "Append structured buffers are not supported" );                          break;
+            case D3D_SIT_UAV_CONSUME_STRUCTURED:        UNSUPPORTED( "Consume structured buffers are not supported" );                         break;
+            case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" );                 break;
+            // clang-format on
+            default: UNEXPECTED("Unexpected resource type");
         }
+        ResourceNamesPoolSize += Name.length() + 1;
+        auto it = ResourceNamesTmpPool.emplace(std::move(Name));
+        Resources.emplace_back(
+            it.first->c_str(),
+            BindingDesc.BindPoint,
+            BindCount,
+            BindingDesc.Type,
+            BindingDesc.Dimension,
+            D3DShaderResourceAttribs::InvalidSamplerId);
+    }
 
-        OnResourcesCounted(RC, ResourceNamesPoolSize);
+    OnResourcesCounted(RC, ResourceNamesPoolSize);
 
-        std::vector<size_t, STDAllocatorRawMem<size_t> > TexSRVInds( STD_ALLOCATOR_RAW_MEM(size_t, GetRawAllocator(), "Allocator for vector<size_t>") );
-        TexSRVInds.reserve(RC.NumTexSRVs);
+    std::vector<size_t, STDAllocatorRawMem<size_t>> TexSRVInds(STD_ALLOCATOR_RAW_MEM(size_t, GetRawAllocator(), "Allocator for vector<size_t>"));
+    TexSRVInds.reserve(RC.NumTexSRVs);
 
-        for (size_t ResInd = 0; ResInd < Resources.size(); ++ResInd)
+    for (size_t ResInd = 0; ResInd < Resources.size(); ++ResInd)
+    {
+        const auto& Res = Resources[ResInd];
+        switch (Res.GetInputType())
         {
-            const auto& Res = Resources[ResInd];
-            switch (Res.GetInputType())
+            case D3D_SIT_CBUFFER:
+            {
+                OnNewCB(Res);
+                break;
+            }
+
+            case D3D_SIT_TBUFFER:
             {
-                case D3D_SIT_CBUFFER:
+                UNSUPPORTED("TBuffers are not supported");
+                break;
+            }
+
+            case D3D_SIT_TEXTURE:
+            {
+                if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER)
                 {
-                    OnNewCB( Res );
-                    break;
+                    OnNewBuffSRV(Res);
                 }
-            
-                case D3D_SIT_TBUFFER:
+                else
                 {
-                    UNSUPPORTED( "TBuffers are not supported" );
-                    break;
+                    // Texture SRVs must be processed all samplers are initialized
+                    TexSRVInds.push_back(ResInd);
                 }
+                break;
+            }
 
-                case D3D_SIT_TEXTURE:
-                {
-                    if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER)
-                    {
-                        OnNewBuffSRV( Res );
-                    }
-                    else
-                    {
-                        // Texture SRVs must be processed all samplers are initialized
-                        TexSRVInds.push_back(ResInd);
-                    }
-                    break;
-                }
+            case D3D_SIT_SAMPLER:
+            {
+                OnNewSampler(Res);
+                break;
+            }
 
-                case D3D_SIT_SAMPLER:
+            case D3D_SIT_UAV_RWTYPED:
+            {
+                if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER)
                 {
-                    OnNewSampler( Res );
-                    break;
+                    OnNewBuffUAV(Res);
                 }
-
-                case D3D_SIT_UAV_RWTYPED:
+                else
                 {
-                    if (Res.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER)
-                    {
-                        OnNewBuffUAV( Res );
-                    }
-                    else
-                    {
-                        OnNewTexUAV( Res );
-                    }
-                    break;
+                    OnNewTexUAV(Res);
                 }
+                break;
+            }
 
-                case D3D_SIT_STRUCTURED:
-                {
-                    OnNewBuffSRV( Res );
-                    break;
-                }
+            case D3D_SIT_STRUCTURED:
+            {
+                OnNewBuffSRV(Res);
+                break;
+            }
 
-                case D3D_SIT_UAV_RWSTRUCTURED:
-                {
-                    OnNewBuffUAV( Res );
-                    break;
-                }
+            case D3D_SIT_UAV_RWSTRUCTURED:
+            {
+                OnNewBuffUAV(Res);
+                break;
+            }
 
-                case D3D_SIT_BYTEADDRESS:
-                {
-                    OnNewBuffSRV( Res );
-                    break;
-                }
+            case D3D_SIT_BYTEADDRESS:
+            {
+                OnNewBuffSRV(Res);
+                break;
+            }
 
-                case D3D_SIT_UAV_RWBYTEADDRESS:
-                {
-                    OnNewBuffUAV( Res );
-                    break;
-                }
+            case D3D_SIT_UAV_RWBYTEADDRESS:
+            {
+                OnNewBuffUAV(Res);
+                break;
+            }
 
-                case D3D_SIT_UAV_APPEND_STRUCTURED:
-                {
-                    UNSUPPORTED( "Append structured buffers are not supported" );
-                    break;
-                }
+            case D3D_SIT_UAV_APPEND_STRUCTURED:
+            {
+                UNSUPPORTED("Append structured buffers are not supported");
+                break;
+            }
 
-                case D3D_SIT_UAV_CONSUME_STRUCTURED:
-                {
-                    UNSUPPORTED( "Consume structured buffers are not supported" );
-                    break;
-                }
+            case D3D_SIT_UAV_CONSUME_STRUCTURED:
+            {
+                UNSUPPORTED("Consume structured buffers are not supported");
+                break;
+            }
 
-                case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
-                {
-                    UNSUPPORTED( "RW structured buffers with counter are not supported" );
-                    break;
-                }
+            case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
+            {
+                UNSUPPORTED("RW structured buffers with counter are not supported");
+                break;
+            }
 
-                default:
-                {
-                    UNEXPECTED("Unexpected resource input type");
-                }
+            default:
+            {
+                UNEXPECTED("Unexpected resource input type");
             }
         }
+    }
 
-        // Process texture SRVs. We need to do this after all samplers are initialized
-        for (auto TexSRVInd : TexSRVInds)
-        {
-            OnNewTexSRV(Resources[TexSRVInd]);
-        }
+    // Process texture SRVs. We need to do this after all samplers are initialized
+    for (auto TexSRVInd : TexSRVInds)
+    {
+        OnNewTexSRV(Resources[TexSRVInd]);
     }
 }
+
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h b/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h
index d474ecf0..25c562bd 100644
--- a/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h
+++ b/Graphics/GraphicsEngineD3DBase/include/D3DTypeConversionImpl.h
@@ -33,540 +33,553 @@
 namespace Diligent
 {
 
-    template<typename D3D_COMPARISON_FUNC>
-    inline D3D_COMPARISON_FUNC ComparisonFuncToD3DComparisonFunc(COMPARISON_FUNCTION Func)
+template <typename D3D_COMPARISON_FUNC>
+inline D3D_COMPARISON_FUNC ComparisonFuncToD3DComparisonFunc(COMPARISON_FUNCTION Func)
+{
+    // D3D12_COMPARISON_FUNC is equal to D3D11_COMPARISON_FUNC
+    switch (Func)
     {
-        // D3D12_COMPARISON_FUNC is equal to D3D11_COMPARISON_FUNC
-        switch(Func)
-        {
-            case COMPARISON_FUNC_UNKNOWN: UNEXPECTED("Comparison function is not specified" ); return D3D_COMPARISON_FUNC_ALWAYS;
-            case COMPARISON_FUNC_NEVER:         return D3D_COMPARISON_FUNC_NEVER;
-	        case COMPARISON_FUNC_LESS:          return D3D_COMPARISON_FUNC_LESS;
-	        case COMPARISON_FUNC_EQUAL:         return D3D_COMPARISON_FUNC_EQUAL;
-	        case COMPARISON_FUNC_LESS_EQUAL:    return D3D_COMPARISON_FUNC_LESS_EQUAL;
-	        case COMPARISON_FUNC_GREATER:       return D3D_COMPARISON_FUNC_GREATER;
-	        case COMPARISON_FUNC_NOT_EQUAL:     return D3D_COMPARISON_FUNC_NOT_EQUAL;
-	        case COMPARISON_FUNC_GREATER_EQUAL: return D3D_COMPARISON_FUNC_GREATER_EQUAL;
-	        case COMPARISON_FUNC_ALWAYS:        return D3D_COMPARISON_FUNC_ALWAYS;
-            default: UNEXPECTED("Unknown comparison function" ); return D3D_COMPARISON_FUNC_ALWAYS;
-        }
+        // clang-format off
+        case COMPARISON_FUNC_UNKNOWN: UNEXPECTED("Comparison function is not specified" ); return D3D_COMPARISON_FUNC_ALWAYS;
+        case COMPARISON_FUNC_NEVER:         return D3D_COMPARISON_FUNC_NEVER;
+	    case COMPARISON_FUNC_LESS:          return D3D_COMPARISON_FUNC_LESS;
+	    case COMPARISON_FUNC_EQUAL:         return D3D_COMPARISON_FUNC_EQUAL;
+	    case COMPARISON_FUNC_LESS_EQUAL:    return D3D_COMPARISON_FUNC_LESS_EQUAL;
+	    case COMPARISON_FUNC_GREATER:       return D3D_COMPARISON_FUNC_GREATER;
+	    case COMPARISON_FUNC_NOT_EQUAL:     return D3D_COMPARISON_FUNC_NOT_EQUAL;
+	    case COMPARISON_FUNC_GREATER_EQUAL: return D3D_COMPARISON_FUNC_GREATER_EQUAL;
+	    case COMPARISON_FUNC_ALWAYS:        return D3D_COMPARISON_FUNC_ALWAYS;
+        default: UNEXPECTED("Unknown comparison function" ); return D3D_COMPARISON_FUNC_ALWAYS;
+            // clang-format on
     }
+}
 
 
-    template<typename D3D_TEXTURE_ADDRESS_MODE>
-    D3D_TEXTURE_ADDRESS_MODE TexAddressModeToD3DAddressMode(TEXTURE_ADDRESS_MODE Mode)
+template <typename D3D_TEXTURE_ADDRESS_MODE>
+D3D_TEXTURE_ADDRESS_MODE TexAddressModeToD3DAddressMode(TEXTURE_ADDRESS_MODE Mode)
+{
+    switch (Mode)
     {
-        switch(Mode)
-        {
-            case TEXTURE_ADDRESS_UNKNOWN: UNEXPECTED("Texture address mode is not specified" ); return D3D_TEXTURE_ADDRESS_CLAMP;
-            case TEXTURE_ADDRESS_WRAP:          return D3D_TEXTURE_ADDRESS_WRAP;
-            case TEXTURE_ADDRESS_MIRROR:        return D3D_TEXTURE_ADDRESS_MIRROR;
-            case TEXTURE_ADDRESS_CLAMP:         return D3D_TEXTURE_ADDRESS_CLAMP;
-            case TEXTURE_ADDRESS_BORDER:        return D3D_TEXTURE_ADDRESS_BORDER;
-            case TEXTURE_ADDRESS_MIRROR_ONCE:   return D3D_TEXTURE_ADDRESS_MIRROR_ONCE;
-            default: UNEXPECTED("Unknown texture address mode" ); return D3D_TEXTURE_ADDRESS_CLAMP;
-        }
-    }   
-
-    template<typename D3D_PRIM_TOPOLOGY>
-    D3D_PRIM_TOPOLOGY TopologyToD3DTopology(PRIMITIVE_TOPOLOGY Topology)
+        // clang-format off
+        case TEXTURE_ADDRESS_UNKNOWN: UNEXPECTED("Texture address mode is not specified" ); return D3D_TEXTURE_ADDRESS_CLAMP;
+        case TEXTURE_ADDRESS_WRAP:          return D3D_TEXTURE_ADDRESS_WRAP;
+        case TEXTURE_ADDRESS_MIRROR:        return D3D_TEXTURE_ADDRESS_MIRROR;
+        case TEXTURE_ADDRESS_CLAMP:         return D3D_TEXTURE_ADDRESS_CLAMP;
+        case TEXTURE_ADDRESS_BORDER:        return D3D_TEXTURE_ADDRESS_BORDER;
+        case TEXTURE_ADDRESS_MIRROR_ONCE:   return D3D_TEXTURE_ADDRESS_MIRROR_ONCE;
+        default: UNEXPECTED("Unknown texture address mode" ); return D3D_TEXTURE_ADDRESS_CLAMP;
+            // clang-format on
+    }
+}
+
+template <typename D3D_PRIM_TOPOLOGY>
+D3D_PRIM_TOPOLOGY TopologyToD3DTopology(PRIMITIVE_TOPOLOGY Topology)
+{
+    static bool                                                             bIsInit         = false;
+    static std::array<D3D_PRIM_TOPOLOGY, PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES> d3dPrimTopology = {};
+    if (!bIsInit)
     {
-        static bool bIsInit = false;
-        static std::array<D3D_PRIM_TOPOLOGY, PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES> d3dPrimTopology = {};
-        if( !bIsInit )
-        {
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_UNDEFINED]      =  D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_LIST]  =  D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP] =  D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_POINT_LIST]     =  D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_LINE_LIST]      =  D3D_PRIMITIVE_TOPOLOGY_LINELIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST;
-            d3dPrimTopology[PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST;
-            
-            bIsInit = true;
-        }
-
-        VERIFY_EXPR(Topology >= PRIMITIVE_TOPOLOGY_UNDEFINED && Topology<PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES);
-        return d3dPrimTopology[Topology];
+        // clang-format off
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_UNDEFINED]      =  D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_LIST]  =  D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP] =  D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_POINT_LIST]     =  D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_LINE_LIST]      =  D3D_PRIMITIVE_TOPOLOGY_LINELIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST]  = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST;
+        d3dPrimTopology[PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST] = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST;
+        // clang-format on
+        bIsInit = true;
     }
 
+    VERIFY_EXPR(Topology >= PRIMITIVE_TOPOLOGY_UNDEFINED && Topology < PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES);
+    return d3dPrimTopology[Topology];
+}
 
-    // ================= Rasterizer state attributes conversion functions ================= 
 
-    template<typename D3D_FILL_MODE>
-    D3D_FILL_MODE FillModeToD3DFillMode(FILL_MODE FillMode)
+// ================= Rasterizer state attributes conversion functions =================
+
+template <typename D3D_FILL_MODE>
+D3D_FILL_MODE FillModeToD3DFillMode(FILL_MODE FillMode)
+{
+    // D3D12_FILL_MODE is identical tp D3D11_FILL_MODE
+    static bool                                           bIsInit      = false;
+    static std::array<D3D_FILL_MODE, FILL_MODE_NUM_MODES> d3dFillModes = {};
+    if (!bIsInit)
+    {
+        d3dFillModes[FILL_MODE_WIREFRAME] = D3D_FILL_MODE_WIREFRAME;
+        d3dFillModes[FILL_MODE_SOLID]     = D3D_FILL_MODE_SOLID;
+
+        bIsInit = true;
+    }
+    if (FILL_MODE_UNDEFINED < FillMode && FillMode < FILL_MODE_NUM_MODES)
+    {
+        auto d3dFillMode = d3dFillModes[FillMode];
+        VERIFY(d3dFillMode != 0, "Incorrect fill mode");
+        return d3dFillMode;
+    }
+    else
     {
-        // D3D12_FILL_MODE is identical tp D3D11_FILL_MODE
-        static bool bIsInit = false;
-        static std::array<D3D_FILL_MODE, FILL_MODE_NUM_MODES> d3dFillModes = {};
-        if( !bIsInit )
-        {
-            d3dFillModes[ FILL_MODE_WIREFRAME ] = D3D_FILL_MODE_WIREFRAME;
-            d3dFillModes[ FILL_MODE_SOLID ]     = D3D_FILL_MODE_SOLID;
-
-            bIsInit = true;
-        }
-        if( FILL_MODE_UNDEFINED < FillMode && FillMode < FILL_MODE_NUM_MODES )
-        {
-            auto d3dFillMode = d3dFillModes[FillMode];
-            VERIFY( d3dFillMode != 0, "Incorrect fill mode" );
-            return d3dFillMode;
-        }
-        else
-        {
-            UNEXPECTED( "Incorrect fill mode (", FillMode, ")" );
-            return static_cast<D3D_FILL_MODE>(0);
-        }
+        UNEXPECTED("Incorrect fill mode (", FillMode, ")");
+        return static_cast<D3D_FILL_MODE>(0);
     }
+}
 
-    template<typename D3D_CULL_MODE>
-    D3D_CULL_MODE CullModeToD3DCullMode( CULL_MODE CullMode )
+template <typename D3D_CULL_MODE>
+D3D_CULL_MODE CullModeToD3DCullMode(CULL_MODE CullMode)
+{
+    // D3D_CULL_MODE is identical to D3D11_CULL_MODE
+    static bool                                           bIsInit      = false;
+    static std::array<D3D_CULL_MODE, CULL_MODE_NUM_MODES> d3dCullModes = {};
+    if (!bIsInit)
     {
-        // D3D_CULL_MODE is identical to D3D11_CULL_MODE
-        static bool bIsInit = false;
-        static std::array<D3D_CULL_MODE, CULL_MODE_NUM_MODES> d3dCullModes = {};
-        if( !bIsInit )
-        {
-            d3dCullModes[ CULL_MODE_NONE  ] = D3D_CULL_MODE_NONE;
-            d3dCullModes[ CULL_MODE_FRONT ] = D3D_CULL_MODE_FRONT;
-            d3dCullModes[ CULL_MODE_BACK  ] = D3D_CULL_MODE_BACK;
-
-            bIsInit = true;
-        }
-
-        if( CULL_MODE_UNDEFINED < CullMode && CullMode < CULL_MODE_NUM_MODES )
-        {
-            auto d3dCullMode = d3dCullModes[CullMode];
-            VERIFY( d3dCullMode != 0, "Incorrect cull mode" );
-            return d3dCullMode;
-        }
-        else
-        {
-            UNEXPECTED( "Incorrect cull mode (", CullMode, ")" );
-            return static_cast<D3D_CULL_MODE>(0);
-        }
+        d3dCullModes[CULL_MODE_NONE]  = D3D_CULL_MODE_NONE;
+        d3dCullModes[CULL_MODE_FRONT] = D3D_CULL_MODE_FRONT;
+        d3dCullModes[CULL_MODE_BACK]  = D3D_CULL_MODE_BACK;
+
+        bIsInit = true;
     }
 
-    template<typename D3D_RASTERIZER_DESC, typename D3D_FILL_MODE, typename D3D_CULL_MODE>
-    void RasterizerStateDesc_To_D3D_RASTERIZER_DESC(const RasterizerStateDesc &RasterizerDesc, D3D_RASTERIZER_DESC &d3dRSDesc)
+    if (CULL_MODE_UNDEFINED < CullMode && CullMode < CULL_MODE_NUM_MODES)
     {
-        d3dRSDesc.FillMode = FillModeToD3DFillMode<D3D_FILL_MODE>(RasterizerDesc.FillMode);
-        d3dRSDesc.CullMode = CullModeToD3DCullMode<D3D_CULL_MODE>(RasterizerDesc.CullMode);
-        d3dRSDesc.FrontCounterClockwise = RasterizerDesc.FrontCounterClockwise ? TRUE : FALSE;
-        d3dRSDesc.DepthBias             = RasterizerDesc.DepthBias;
-        d3dRSDesc.DepthBiasClamp        = RasterizerDesc.DepthBiasClamp;  
-        d3dRSDesc.SlopeScaledDepthBias  = RasterizerDesc.SlopeScaledDepthBias;
-        d3dRSDesc.DepthClipEnable       = RasterizerDesc.DepthClipEnable       ? TRUE : FALSE;
-
-        //d3d12RSDesc.ScissorEnable         = RSDesc.ScissorEnable         ? TRUE : FALSE;    
-
-        d3dRSDesc.AntialiasedLineEnable = RasterizerDesc.AntialiasedLineEnable ? TRUE : FALSE;
-        d3dRSDesc.MultisampleEnable     = d3dRSDesc.AntialiasedLineEnable;
+        auto d3dCullMode = d3dCullModes[CullMode];
+        VERIFY(d3dCullMode != 0, "Incorrect cull mode");
+        return d3dCullMode;
     }
+    else
+    {
+        UNEXPECTED("Incorrect cull mode (", CullMode, ")");
+        return static_cast<D3D_CULL_MODE>(0);
+    }
+}
+
+template <typename D3D_RASTERIZER_DESC, typename D3D_FILL_MODE, typename D3D_CULL_MODE>
+void RasterizerStateDesc_To_D3D_RASTERIZER_DESC(const RasterizerStateDesc& RasterizerDesc, D3D_RASTERIZER_DESC& d3dRSDesc)
+{
+    d3dRSDesc.FillMode              = FillModeToD3DFillMode<D3D_FILL_MODE>(RasterizerDesc.FillMode);
+    d3dRSDesc.CullMode              = CullModeToD3DCullMode<D3D_CULL_MODE>(RasterizerDesc.CullMode);
+    d3dRSDesc.FrontCounterClockwise = RasterizerDesc.FrontCounterClockwise ? TRUE : FALSE;
+    d3dRSDesc.DepthBias             = RasterizerDesc.DepthBias;
+    d3dRSDesc.DepthBiasClamp        = RasterizerDesc.DepthBiasClamp;
+    d3dRSDesc.SlopeScaledDepthBias  = RasterizerDesc.SlopeScaledDepthBias;
+    d3dRSDesc.DepthClipEnable       = RasterizerDesc.DepthClipEnable ? TRUE : FALSE;
+
+    //d3d12RSDesc.ScissorEnable         = RSDesc.ScissorEnable         ? TRUE : FALSE;
+
+    d3dRSDesc.AntialiasedLineEnable = RasterizerDesc.AntialiasedLineEnable ? TRUE : FALSE;
+    d3dRSDesc.MultisampleEnable     = d3dRSDesc.AntialiasedLineEnable;
+}
 
 
 
-    // ================= Blend state attributes conversion functions ================= 
+// ================= Blend state attributes conversion functions =================
+
+template <typename D3D_BLEND>
+D3D_BLEND BlendFactorToD3DBlend(BLEND_FACTOR bf)
+{
+    // D3D11_BLEND and D3D12_BLEND are identical
 
-    template<typename D3D_BLEND>
-    D3D_BLEND BlendFactorToD3DBlend( BLEND_FACTOR bf )
+    // Note that this code is safe for multithreaded environments since
+    // bIsInit is set to true only AFTER the entire map is initialized.
+    static bool                                            bIsInit  = false;
+    static std::array<D3D_BLEND, BLEND_FACTOR_NUM_FACTORS> D3DBlend = {};
+    if (!bIsInit)
     {
-        // D3D11_BLEND and D3D12_BLEND are identical
-
-        // Note that this code is safe for multithreaded environments since
-        // bIsInit is set to true only AFTER the entire map is initialized.
-        static bool bIsInit = false;
-        static std::array<D3D_BLEND, BLEND_FACTOR_NUM_FACTORS> D3DBlend = {};
-        if( !bIsInit )
-        {
-            // In a multithreaded environment, several threads can potentially enter
-            // this block. This is not a problem since they will just initialize the 
-            // memory with the same values more than once
-            D3DBlend[ BLEND_FACTOR_ZERO             ] =  D3D_BLEND_ZERO;
-            D3DBlend[ BLEND_FACTOR_ONE              ] =  D3D_BLEND_ONE;
-            D3DBlend[ BLEND_FACTOR_SRC_COLOR        ] =  D3D_BLEND_SRC_COLOR;
-            D3DBlend[ BLEND_FACTOR_INV_SRC_COLOR    ] =  D3D_BLEND_INV_SRC_COLOR;
-            D3DBlend[ BLEND_FACTOR_SRC_ALPHA        ] =  D3D_BLEND_SRC_ALPHA;
-            D3DBlend[ BLEND_FACTOR_INV_SRC_ALPHA    ] =  D3D_BLEND_INV_SRC_ALPHA;
-            D3DBlend[ BLEND_FACTOR_DEST_ALPHA       ] =  D3D_BLEND_DEST_ALPHA;
-            D3DBlend[ BLEND_FACTOR_INV_DEST_ALPHA   ] =  D3D_BLEND_INV_DEST_ALPHA;
-            D3DBlend[ BLEND_FACTOR_DEST_COLOR       ] =  D3D_BLEND_DEST_COLOR;
-            D3DBlend[ BLEND_FACTOR_INV_DEST_COLOR   ] =  D3D_BLEND_INV_DEST_COLOR;
-            D3DBlend[ BLEND_FACTOR_SRC_ALPHA_SAT    ] =  D3D_BLEND_SRC_ALPHA_SAT;
-            D3DBlend[ BLEND_FACTOR_BLEND_FACTOR     ] =  D3D_BLEND_BLEND_FACTOR;
-            D3DBlend[ BLEND_FACTOR_INV_BLEND_FACTOR ] =  D3D_BLEND_INV_BLEND_FACTOR;
-            D3DBlend[ BLEND_FACTOR_SRC1_COLOR       ] =  D3D_BLEND_SRC1_COLOR;
-            D3DBlend[ BLEND_FACTOR_INV_SRC1_COLOR   ] =  D3D_BLEND_INV_SRC1_COLOR;
-            D3DBlend[ BLEND_FACTOR_SRC1_ALPHA       ] =  D3D_BLEND_SRC1_ALPHA;
-            D3DBlend[ BLEND_FACTOR_INV_SRC1_ALPHA   ] =  D3D_BLEND_INV_SRC1_ALPHA;
-
-            bIsInit = true;
-        }
-        if( bf > BLEND_FACTOR_UNDEFINED && bf < BLEND_FACTOR_NUM_FACTORS )
-        {
-            auto d3dbf = D3DBlend[bf];
-            VERIFY( d3dbf != 0, "Incorrect blend factor" );
-            return d3dbf;
-        }
-        else
-        {
-            UNEXPECTED("Incorrect blend factor (", bf, ")" );
-            return static_cast<D3D_BLEND>( 0 );
-        }
+        // In a multithreaded environment, several threads can potentially enter
+        // this block. This is not a problem since they will just initialize the
+        // memory with the same values more than once
+
+        // clang-format off
+        D3DBlend[BLEND_FACTOR_ZERO            ] =  D3D_BLEND_ZERO;
+        D3DBlend[BLEND_FACTOR_ONE             ] =  D3D_BLEND_ONE;
+        D3DBlend[BLEND_FACTOR_SRC_COLOR       ] =  D3D_BLEND_SRC_COLOR;
+        D3DBlend[BLEND_FACTOR_INV_SRC_COLOR   ] =  D3D_BLEND_INV_SRC_COLOR;
+        D3DBlend[BLEND_FACTOR_SRC_ALPHA       ] =  D3D_BLEND_SRC_ALPHA;
+        D3DBlend[BLEND_FACTOR_INV_SRC_ALPHA   ] =  D3D_BLEND_INV_SRC_ALPHA;
+        D3DBlend[BLEND_FACTOR_DEST_ALPHA      ] =  D3D_BLEND_DEST_ALPHA;
+        D3DBlend[BLEND_FACTOR_INV_DEST_ALPHA  ] =  D3D_BLEND_INV_DEST_ALPHA;
+        D3DBlend[BLEND_FACTOR_DEST_COLOR      ] =  D3D_BLEND_DEST_COLOR;
+        D3DBlend[BLEND_FACTOR_INV_DEST_COLOR  ] =  D3D_BLEND_INV_DEST_COLOR;
+        D3DBlend[BLEND_FACTOR_SRC_ALPHA_SAT   ] =  D3D_BLEND_SRC_ALPHA_SAT;
+        D3DBlend[BLEND_FACTOR_BLEND_FACTOR    ] =  D3D_BLEND_BLEND_FACTOR;
+        D3DBlend[BLEND_FACTOR_INV_BLEND_FACTOR] =  D3D_BLEND_INV_BLEND_FACTOR;
+        D3DBlend[BLEND_FACTOR_SRC1_COLOR      ] =  D3D_BLEND_SRC1_COLOR;
+        D3DBlend[BLEND_FACTOR_INV_SRC1_COLOR  ] =  D3D_BLEND_INV_SRC1_COLOR;
+        D3DBlend[BLEND_FACTOR_SRC1_ALPHA      ] =  D3D_BLEND_SRC1_ALPHA;
+        D3DBlend[BLEND_FACTOR_INV_SRC1_ALPHA  ] =  D3D_BLEND_INV_SRC1_ALPHA;
+        // clang-format on
+
+        bIsInit = true;
     }
-
-    template<typename D3D_BLEND_OP>
-    D3D_BLEND_OP BlendOperationToD3DBlendOp( BLEND_OPERATION BlendOp )
+    if (bf > BLEND_FACTOR_UNDEFINED && bf < BLEND_FACTOR_NUM_FACTORS)
     {
-        // D3D12_BLEND_OP and D3D11_BLEND_OP are identical
-
-        static bool bIsInit = false;
-        static std::array<D3D_BLEND_OP, BLEND_OPERATION_NUM_OPERATIONS> D3DBlendOp = {};
-        if( !bIsInit )
-        {
-            D3DBlendOp[ BLEND_OPERATION_ADD          ] = D3D_BLEND_OP_ADD;
-            D3DBlendOp[ BLEND_OPERATION_SUBTRACT     ] = D3D_BLEND_OP_SUBTRACT;
-            D3DBlendOp[ BLEND_OPERATION_REV_SUBTRACT ] = D3D_BLEND_OP_REV_SUBTRACT;
-            D3DBlendOp[ BLEND_OPERATION_MIN          ] = D3D_BLEND_OP_MIN;
-            D3DBlendOp[ BLEND_OPERATION_MAX          ] = D3D_BLEND_OP_MAX;
-
-            bIsInit = true;
-        }
-
-        if( BlendOp > BLEND_OPERATION_UNDEFINED && BlendOp < BLEND_OPERATION_NUM_OPERATIONS )
-        {
-            auto d3dbop = D3DBlendOp[BlendOp];
-            VERIFY( d3dbop != 0, "Incorrect blend operation" );
-            return d3dbop;
-        }
-        else
-        {
-            UNEXPECTED( "Incorrect blend operation (", BlendOp, ")" );
-            return static_cast<D3D_BLEND_OP>(0);
-        }
+        auto d3dbf = D3DBlend[bf];
+        VERIFY(d3dbf != 0, "Incorrect blend factor");
+        return d3dbf;
     }
-    
-    template<typename D3D_BLEND_DESC, typename D3D_BLEND, typename D3D_BLEND_OP>
-    void BlendStateDescToD3DBlendDesc(const BlendStateDesc &BSDesc, D3D_BLEND_DESC &d3d12BlendDesc)
+    else
     {
-        // D3D_BLEND_DESC and D3D11_BLEND_DESC structures are identical
-        d3d12BlendDesc.AlphaToCoverageEnable  = BSDesc.AlphaToCoverageEnable ? TRUE : FALSE;
-        d3d12BlendDesc.IndependentBlendEnable = BSDesc.IndependentBlendEnable ? TRUE : FALSE;
-        VERIFY( BSDesc.MaxRenderTargets >= 8, "Number of render targets is expected to be at least 8" );
-        for( int i = 0; i < 8; ++i )
-        {
-            const auto& SrcRTDesc = BSDesc.RenderTargets[i];
-            auto &DstRTDesc = d3d12BlendDesc.RenderTarget[i];
-            DstRTDesc.BlendEnable = SrcRTDesc.BlendEnable ? TRUE : FALSE;
-
-            DstRTDesc.SrcBlend  = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.SrcBlend);
-            DstRTDesc.DestBlend = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.DestBlend);
-            DstRTDesc.BlendOp   = BlendOperationToD3DBlendOp<D3D_BLEND_OP>(SrcRTDesc.BlendOp);
-
-            DstRTDesc.SrcBlendAlpha  = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.SrcBlendAlpha);
-            DstRTDesc.DestBlendAlpha = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.DestBlendAlpha);
-            DstRTDesc.BlendOpAlpha   = BlendOperationToD3DBlendOp<D3D_BLEND_OP>(SrcRTDesc.BlendOpAlpha);
-
-            DstRTDesc.RenderTargetWriteMask = 
-                ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_RED)   ? D3D_COLOR_WRITE_ENABLE_RED   : 0) | 
-                ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_GREEN) ? D3D_COLOR_WRITE_ENABLE_GREEN : 0) |
-                ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_BLUE)  ? D3D_COLOR_WRITE_ENABLE_BLUE  : 0) |
-                ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_ALPHA) ? D3D_COLOR_WRITE_ENABLE_ALPHA : 0);
-        }
+        UNEXPECTED("Incorrect blend factor (", bf, ")");
+        return static_cast<D3D_BLEND>(0);
     }
+}
 
+template <typename D3D_BLEND_OP>
+D3D_BLEND_OP BlendOperationToD3DBlendOp(BLEND_OPERATION BlendOp)
+{
+    // D3D12_BLEND_OP and D3D11_BLEND_OP are identical
 
+    static bool                                                     bIsInit    = false;
+    static std::array<D3D_BLEND_OP, BLEND_OPERATION_NUM_OPERATIONS> D3DBlendOp = {};
+    if (!bIsInit)
+    {
+        // clang-format off
+        D3DBlendOp[BLEND_OPERATION_ADD         ] = D3D_BLEND_OP_ADD;
+        D3DBlendOp[BLEND_OPERATION_SUBTRACT    ] = D3D_BLEND_OP_SUBTRACT;
+        D3DBlendOp[BLEND_OPERATION_REV_SUBTRACT] = D3D_BLEND_OP_REV_SUBTRACT;
+        D3DBlendOp[BLEND_OPERATION_MIN         ] = D3D_BLEND_OP_MIN;
+        D3DBlendOp[BLEND_OPERATION_MAX         ] = D3D_BLEND_OP_MAX;
+        // clang-format on
+
+        bIsInit = true;
+    }
 
-    // ====================== Depth-stencil state attributes conversion functions ======================
+    if (BlendOp > BLEND_OPERATION_UNDEFINED && BlendOp < BLEND_OPERATION_NUM_OPERATIONS)
+    {
+        auto d3dbop = D3DBlendOp[BlendOp];
+        VERIFY(d3dbop != 0, "Incorrect blend operation");
+        return d3dbop;
+    }
+    else
+    {
+        UNEXPECTED("Incorrect blend operation (", BlendOp, ")");
+        return static_cast<D3D_BLEND_OP>(0);
+    }
+}
 
-    template<typename D3D_STENCIL_OP>
-    D3D_STENCIL_OP StencilOpToD3DStencilOp( STENCIL_OP StencilOp )
+template <typename D3D_BLEND_DESC, typename D3D_BLEND, typename D3D_BLEND_OP>
+void BlendStateDescToD3DBlendDesc(const BlendStateDesc& BSDesc, D3D_BLEND_DESC& d3d12BlendDesc)
+{
+    // D3D_BLEND_DESC and D3D11_BLEND_DESC structures are identical
+    d3d12BlendDesc.AlphaToCoverageEnable  = BSDesc.AlphaToCoverageEnable ? TRUE : FALSE;
+    d3d12BlendDesc.IndependentBlendEnable = BSDesc.IndependentBlendEnable ? TRUE : FALSE;
+    VERIFY(BSDesc.MaxRenderTargets >= 8, "Number of render targets is expected to be at least 8");
+    for (int i = 0; i < 8; ++i)
     {
-        static bool bIsInit = false;
-        static std::array<D3D_STENCIL_OP, STENCIL_OP_NUM_OPS> StOpToD3DStOpMap = {};
-        if( !bIsInit )
-        {
-            StOpToD3DStOpMap[ STENCIL_OP_KEEP     ] = D3D_STENCIL_OP_KEEP;
-            StOpToD3DStOpMap[ STENCIL_OP_ZERO     ] = D3D_STENCIL_OP_ZERO;
-            StOpToD3DStOpMap[ STENCIL_OP_REPLACE  ] = D3D_STENCIL_OP_REPLACE;
-            StOpToD3DStOpMap[ STENCIL_OP_INCR_SAT ] = D3D_STENCIL_OP_INCR_SAT;
-            StOpToD3DStOpMap[ STENCIL_OP_DECR_SAT ] = D3D_STENCIL_OP_DECR_SAT;
-            StOpToD3DStOpMap[ STENCIL_OP_INVERT   ] = D3D_STENCIL_OP_INVERT;
-            StOpToD3DStOpMap[ STENCIL_OP_INCR_WRAP] = D3D_STENCIL_OP_INCR;
-            StOpToD3DStOpMap[ STENCIL_OP_DECR_WRAP] = D3D_STENCIL_OP_DECR;
-
-            bIsInit = true;
-        }
-
-        if( StencilOp > STENCIL_OP_UNDEFINED && StencilOp < STENCIL_OP_NUM_OPS )
-        {
-            auto d3dStencilOp = StOpToD3DStOpMap[StencilOp];
-            VERIFY( d3dStencilOp != 0, "Unexpected stencil op" );
-            return d3dStencilOp;
-        }
-        else
-        {
-            UNEXPECTED( "Stencil operation (", StencilOp, ") is out of allowed range [1, ", STENCIL_OP_NUM_OPS - 1, "]" );
-            return static_cast<D3D_STENCIL_OP>(0);
-        }
+        const auto& SrcRTDesc = BSDesc.RenderTargets[i];
+        auto&       DstRTDesc = d3d12BlendDesc.RenderTarget[i];
+        DstRTDesc.BlendEnable = SrcRTDesc.BlendEnable ? TRUE : FALSE;
+
+        DstRTDesc.SrcBlend  = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.SrcBlend);
+        DstRTDesc.DestBlend = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.DestBlend);
+        DstRTDesc.BlendOp   = BlendOperationToD3DBlendOp<D3D_BLEND_OP>(SrcRTDesc.BlendOp);
+
+        DstRTDesc.SrcBlendAlpha  = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.SrcBlendAlpha);
+        DstRTDesc.DestBlendAlpha = BlendFactorToD3DBlend<D3D_BLEND>(SrcRTDesc.DestBlendAlpha);
+        DstRTDesc.BlendOpAlpha   = BlendOperationToD3DBlendOp<D3D_BLEND_OP>(SrcRTDesc.BlendOpAlpha);
+
+        DstRTDesc.RenderTargetWriteMask =
+            ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_RED) ? D3D_COLOR_WRITE_ENABLE_RED : 0) |
+            ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_GREEN) ? D3D_COLOR_WRITE_ENABLE_GREEN : 0) |
+            ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_BLUE) ? D3D_COLOR_WRITE_ENABLE_BLUE : 0) |
+            ((SrcRTDesc.RenderTargetWriteMask & COLOR_MASK_ALPHA) ? D3D_COLOR_WRITE_ENABLE_ALPHA : 0);
     }
+}
+
+
+
+// ====================== Depth-stencil state attributes conversion functions ======================
 
-    template<typename D3D_DEPTH_STENCILOP_DESC, typename D3D_STENCIL_OP, typename D3D_COMPARISON_FUNC>
-    D3D_DEPTH_STENCILOP_DESC StencilOpDescToD3DStencilOpDesc(const StencilOpDesc &StOpDesc)
+template <typename D3D_STENCIL_OP>
+D3D_STENCIL_OP StencilOpToD3DStencilOp(STENCIL_OP StencilOp)
+{
+    static bool                                           bIsInit          = false;
+    static std::array<D3D_STENCIL_OP, STENCIL_OP_NUM_OPS> StOpToD3DStOpMap = {};
+    if (!bIsInit)
     {
-        // D3D12_DEPTH_STENCILOP_DESC is identical to D3D11_DEPTH_STENCILOP_DESC
-        D3D_DEPTH_STENCILOP_DESC D3DStOpDesc;
-        D3DStOpDesc.StencilFailOp      = StencilOpToD3DStencilOp<D3D_STENCIL_OP>( StOpDesc.StencilFailOp );
-        D3DStOpDesc.StencilDepthFailOp = StencilOpToD3DStencilOp<D3D_STENCIL_OP>( StOpDesc.StencilDepthFailOp );
-        D3DStOpDesc.StencilPassOp      = StencilOpToD3DStencilOp<D3D_STENCIL_OP>( StOpDesc.StencilPassOp );
-        D3DStOpDesc.StencilFunc        = ComparisonFuncToD3DComparisonFunc<D3D_COMPARISON_FUNC>( StOpDesc.StencilFunc );
-        return D3DStOpDesc;
+        // clang-format off
+        StOpToD3DStOpMap[STENCIL_OP_KEEP     ] = D3D_STENCIL_OP_KEEP;
+        StOpToD3DStOpMap[STENCIL_OP_ZERO     ] = D3D_STENCIL_OP_ZERO;
+        StOpToD3DStOpMap[STENCIL_OP_REPLACE  ] = D3D_STENCIL_OP_REPLACE;
+        StOpToD3DStOpMap[STENCIL_OP_INCR_SAT ] = D3D_STENCIL_OP_INCR_SAT;
+        StOpToD3DStOpMap[STENCIL_OP_DECR_SAT ] = D3D_STENCIL_OP_DECR_SAT;
+        StOpToD3DStOpMap[STENCIL_OP_INVERT   ] = D3D_STENCIL_OP_INVERT;
+        StOpToD3DStOpMap[STENCIL_OP_INCR_WRAP] = D3D_STENCIL_OP_INCR;
+        StOpToD3DStOpMap[STENCIL_OP_DECR_WRAP] = D3D_STENCIL_OP_DECR;
+        // clang-format on
+
+        bIsInit = true;
     }
 
-    template<typename D3D_DEPTH_STENCIL_DESC, typename D3D_DEPTH_STENCILOP_DESC, typename D3D_STENCIL_OP, typename D3D_COMPARISON_FUNC>
-    void DepthStencilStateDesc_To_D3D_DEPTH_STENCIL_DESC(const DepthStencilStateDesc &DepthStencilDesc, D3D_DEPTH_STENCIL_DESC &d3dDSSDesc)
+    if (StencilOp > STENCIL_OP_UNDEFINED && StencilOp < STENCIL_OP_NUM_OPS)
+    {
+        auto d3dStencilOp = StOpToD3DStOpMap[StencilOp];
+        VERIFY(d3dStencilOp != 0, "Unexpected stencil op");
+        return d3dStencilOp;
+    }
+    else
     {
-        // D3D_DEPTH_STENCIL_DESC is identical to D3D11_DEPTH_STENCIL_DESC
-        d3dDSSDesc.DepthEnable       = DepthStencilDesc.DepthEnable ? TRUE : FALSE;
-        d3dDSSDesc.DepthWriteMask    = DepthStencilDesc.DepthWriteEnable ? D3D_DEPTH_WRITE_MASK_ALL : D3D_DEPTH_WRITE_MASK_ZERO;
-        d3dDSSDesc.DepthFunc         = ComparisonFuncToD3DComparisonFunc<D3D_COMPARISON_FUNC>( DepthStencilDesc.DepthFunc );
-        d3dDSSDesc.StencilEnable     = DepthStencilDesc.StencilEnable ? TRUE : FALSE;
-        d3dDSSDesc.StencilReadMask   = DepthStencilDesc.StencilReadMask;
-        d3dDSSDesc.StencilWriteMask  = DepthStencilDesc.StencilWriteMask;
-        d3dDSSDesc.FrontFace         = StencilOpDescToD3DStencilOpDesc<D3D_DEPTH_STENCILOP_DESC, D3D_STENCIL_OP, D3D_COMPARISON_FUNC>( DepthStencilDesc.FrontFace );
-        d3dDSSDesc.BackFace          = StencilOpDescToD3DStencilOpDesc<D3D_DEPTH_STENCILOP_DESC, D3D_STENCIL_OP, D3D_COMPARISON_FUNC>( DepthStencilDesc.BackFace );
+        UNEXPECTED("Stencil operation (", StencilOp, ") is out of allowed range [1, ", STENCIL_OP_NUM_OPS - 1, "]");
+        return static_cast<D3D_STENCIL_OP>(0);
     }
+}
+
+template <typename D3D_DEPTH_STENCILOP_DESC, typename D3D_STENCIL_OP, typename D3D_COMPARISON_FUNC>
+D3D_DEPTH_STENCILOP_DESC StencilOpDescToD3DStencilOpDesc(const StencilOpDesc& StOpDesc)
+{
+    // D3D12_DEPTH_STENCILOP_DESC is identical to D3D11_DEPTH_STENCILOP_DESC
+    D3D_DEPTH_STENCILOP_DESC D3DStOpDesc;
+    D3DStOpDesc.StencilFailOp      = StencilOpToD3DStencilOp<D3D_STENCIL_OP>(StOpDesc.StencilFailOp);
+    D3DStOpDesc.StencilDepthFailOp = StencilOpToD3DStencilOp<D3D_STENCIL_OP>(StOpDesc.StencilDepthFailOp);
+    D3DStOpDesc.StencilPassOp      = StencilOpToD3DStencilOp<D3D_STENCIL_OP>(StOpDesc.StencilPassOp);
+    D3DStOpDesc.StencilFunc        = ComparisonFuncToD3DComparisonFunc<D3D_COMPARISON_FUNC>(StOpDesc.StencilFunc);
+    return D3DStOpDesc;
+}
+
+template <typename D3D_DEPTH_STENCIL_DESC, typename D3D_DEPTH_STENCILOP_DESC, typename D3D_STENCIL_OP, typename D3D_COMPARISON_FUNC>
+void DepthStencilStateDesc_To_D3D_DEPTH_STENCIL_DESC(const DepthStencilStateDesc& DepthStencilDesc, D3D_DEPTH_STENCIL_DESC& d3dDSSDesc)
+{
+    // D3D_DEPTH_STENCIL_DESC is identical to D3D11_DEPTH_STENCIL_DESC
+    d3dDSSDesc.DepthEnable      = DepthStencilDesc.DepthEnable ? TRUE : FALSE;
+    d3dDSSDesc.DepthWriteMask   = DepthStencilDesc.DepthWriteEnable ? D3D_DEPTH_WRITE_MASK_ALL : D3D_DEPTH_WRITE_MASK_ZERO;
+    d3dDSSDesc.DepthFunc        = ComparisonFuncToD3DComparisonFunc<D3D_COMPARISON_FUNC>(DepthStencilDesc.DepthFunc);
+    d3dDSSDesc.StencilEnable    = DepthStencilDesc.StencilEnable ? TRUE : FALSE;
+    d3dDSSDesc.StencilReadMask  = DepthStencilDesc.StencilReadMask;
+    d3dDSSDesc.StencilWriteMask = DepthStencilDesc.StencilWriteMask;
+    d3dDSSDesc.FrontFace        = StencilOpDescToD3DStencilOpDesc<D3D_DEPTH_STENCILOP_DESC, D3D_STENCIL_OP, D3D_COMPARISON_FUNC>(DepthStencilDesc.FrontFace);
+    d3dDSSDesc.BackFace         = StencilOpDescToD3DStencilOpDesc<D3D_DEPTH_STENCILOP_DESC, D3D_STENCIL_OP, D3D_COMPARISON_FUNC>(DepthStencilDesc.BackFace);
+}
 
 
 
-    template<typename D3D_INPUT_ELEMENT_DESC>
-    void LayoutElements_To_D3D_INPUT_ELEMENT_DESCs(const InputLayoutDesc& InputLayout, 
-                                                   std::vector<D3D_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D_INPUT_ELEMENT_DESC>> &D3DInputElements)
+template <typename D3D_INPUT_ELEMENT_DESC>
+void LayoutElements_To_D3D_INPUT_ELEMENT_DESCs(const InputLayoutDesc&                                                           InputLayout,
+                                               std::vector<D3D_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D_INPUT_ELEMENT_DESC>>& D3DInputElements)
+{
+    // D3D12_INPUT_ELEMENT_DESC and D3D11_INPUT_ELEMENT_DESC are identical
+    D3DInputElements.resize(InputLayout.NumElements);
+    for (Uint32 iElem = 0; iElem < InputLayout.NumElements; ++iElem)
     {
-        // D3D12_INPUT_ELEMENT_DESC and D3D11_INPUT_ELEMENT_DESC are identical
-        D3DInputElements.resize(InputLayout.NumElements);
-        for(Uint32 iElem=0; iElem < InputLayout.NumElements; ++iElem)
-        {
-            const auto &CurrElem = InputLayout.LayoutElements[iElem];
-            auto &D3DElem = D3DInputElements[iElem];
-            D3DElem.SemanticName         = CurrElem.HLSLSemantic;
-            D3DElem.SemanticIndex        = CurrElem.InputIndex;
-            D3DElem.AlignedByteOffset    = CurrElem.RelativeOffset;
-            D3DElem.InputSlot            = CurrElem.BufferSlot;
-            D3DElem.Format               = TypeToDXGI_Format(CurrElem.ValueType, CurrElem.NumComponents, CurrElem.IsNormalized);
-            D3DElem.InputSlotClass       = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? D3D_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
-            D3DElem.InstanceDataStepRate = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? 0 : CurrElem.InstanceDataStepRate;
-        }
+        const auto& CurrElem         = InputLayout.LayoutElements[iElem];
+        auto&       D3DElem          = D3DInputElements[iElem];
+        D3DElem.SemanticName         = CurrElem.HLSLSemantic;
+        D3DElem.SemanticIndex        = CurrElem.InputIndex;
+        D3DElem.AlignedByteOffset    = CurrElem.RelativeOffset;
+        D3DElem.InputSlot            = CurrElem.BufferSlot;
+        D3DElem.Format               = TypeToDXGI_Format(CurrElem.ValueType, CurrElem.NumComponents, CurrElem.IsNormalized);
+        D3DElem.InputSlotClass       = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? D3D_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
+        D3DElem.InstanceDataStepRate = (CurrElem.Frequency == LayoutElement::FREQUENCY_PER_VERTEX) ? 0 : CurrElem.InstanceDataStepRate;
     }
+}
 
 
-    template<typename D3D_FILTER>
-    D3D_FILTER FilterTypeToD3DFilter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter)
+template <typename D3D_FILTER>
+D3D_FILTER FilterTypeToD3DFilter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter)
+{
+    switch (MinFilter)
     {
-        switch( MinFilter )
-        {
-            // Regular filters
-            case FILTER_TYPE_POINT:
-                if( MagFilter == FILTER_TYPE_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_POINT )
-                        return D3D_FILTER_MIN_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_LINEAR )
-                        return D3D_FILTER_MIN_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_POINT )
-	                    return D3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_LINEAR )
-                        return D3D_FILTER_MIN_POINT_MAG_MIP_LINEAR;
-                }
+        // Regular filters
+        case FILTER_TYPE_POINT:
+            if (MagFilter == FILTER_TYPE_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_POINT)
+                    return D3D_FILTER_MIN_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_LINEAR)
+                    return D3D_FILTER_MIN_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_POINT)
+                    return D3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_LINEAR)
+                    return D3D_FILTER_MIN_POINT_MAG_MIP_LINEAR;
+            }
             break;
-        
-            case FILTER_TYPE_LINEAR:
-                if( MagFilter == FILTER_TYPE_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_POINT )
-                        return D3D_FILTER_MIN_LINEAR_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_LINEAR )
-                        return D3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_POINT )
-	                    return D3D_FILTER_MIN_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_LINEAR )
-                        return D3D_FILTER_MIN_MAG_MIP_LINEAR;
-                }
+
+        case FILTER_TYPE_LINEAR:
+            if (MagFilter == FILTER_TYPE_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_POINT)
+                    return D3D_FILTER_MIN_LINEAR_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_LINEAR)
+                    return D3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_POINT)
+                    return D3D_FILTER_MIN_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_LINEAR)
+                    return D3D_FILTER_MIN_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_ANISOTROPIC:
-                VERIFY( MagFilter == FILTER_TYPE_ANISOTROPIC && MipFilter == FILTER_TYPE_ANISOTROPIC,
-                        "For anistropic filtering, all filters must be anisotropic" );
-                return D3D_FILTER_ANISOTROPIC;
+        case FILTER_TYPE_ANISOTROPIC:
+            VERIFY(MagFilter == FILTER_TYPE_ANISOTROPIC && MipFilter == FILTER_TYPE_ANISOTROPIC,
+                   "For anistropic filtering, all filters must be anisotropic");
+            return D3D_FILTER_ANISOTROPIC;
             break;
 
 
 
-            // Comparison filters
-            case FILTER_TYPE_COMPARISON_POINT:
-                if( MagFilter == FILTER_TYPE_COMPARISON_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_COMPARISON_POINT )
-                        return D3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                        return D3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_COMPARISON_POINT )
-	                    return D3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                        return D3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR;
-                }
+        // Comparison filters
+        case FILTER_TYPE_COMPARISON_POINT:
+            if (MagFilter == FILTER_TYPE_COMPARISON_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_COMPARISON_POINT)
+                    return D3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR)
+                    return D3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_COMPARISON_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_COMPARISON_POINT)
+                    return D3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR)
+                    return D3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_COMPARISON_LINEAR:
-                if( MagFilter == FILTER_TYPE_COMPARISON_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_COMPARISON_POINT )
-                        return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                        return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_COMPARISON_POINT )
-	                    return D3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_COMPARISON_LINEAR )
-                        return D3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
-                }
+        case FILTER_TYPE_COMPARISON_LINEAR:
+            if (MagFilter == FILTER_TYPE_COMPARISON_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_COMPARISON_POINT)
+                    return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR)
+                    return D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_COMPARISON_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_COMPARISON_POINT)
+                    return D3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_COMPARISON_LINEAR)
+                    return D3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_COMPARISON_ANISOTROPIC:
-                VERIFY( MagFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC && MipFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC,
-                        "For comparison anistropic filtering, all filters must be anisotropic" );
-                return D3D_FILTER_COMPARISON_ANISOTROPIC;
+        case FILTER_TYPE_COMPARISON_ANISOTROPIC:
+            VERIFY(MagFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC && MipFilter == FILTER_TYPE_COMPARISON_ANISOTROPIC,
+                   "For comparison anistropic filtering, all filters must be anisotropic");
+            return D3D_FILTER_COMPARISON_ANISOTROPIC;
             break;
 
 
 
-            // Minimum filters
-            case FILTER_TYPE_MINIMUM_POINT:
-                if( MagFilter == FILTER_TYPE_MINIMUM_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_MINIMUM_POINT )
-                        return D3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                        return D3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_MINIMUM_POINT )
-	                    return D3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                        return D3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR;
-                }
+        // Minimum filters
+        case FILTER_TYPE_MINIMUM_POINT:
+            if (MagFilter == FILTER_TYPE_MINIMUM_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_MINIMUM_POINT)
+                    return D3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR)
+                    return D3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_MINIMUM_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_MINIMUM_POINT)
+                    return D3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR)
+                    return D3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_MINIMUM_LINEAR:
-                if( MagFilter == FILTER_TYPE_MINIMUM_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_MINIMUM_POINT )
-                        return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                        return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_MINIMUM_POINT )
-	                    return D3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MINIMUM_LINEAR )
-                        return D3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR;
-                }
+        case FILTER_TYPE_MINIMUM_LINEAR:
+            if (MagFilter == FILTER_TYPE_MINIMUM_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_MINIMUM_POINT)
+                    return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR)
+                    return D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_MINIMUM_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_MINIMUM_POINT)
+                    return D3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MINIMUM_LINEAR)
+                    return D3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_MINIMUM_ANISOTROPIC:
-                VERIFY( MagFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC,
-                        "For minimum anistropic filtering, all filters must be anisotropic" );
-                return D3D_FILTER_MINIMUM_ANISOTROPIC;
+        case FILTER_TYPE_MINIMUM_ANISOTROPIC:
+            VERIFY(MagFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MINIMUM_ANISOTROPIC,
+                   "For minimum anistropic filtering, all filters must be anisotropic");
+            return D3D_FILTER_MINIMUM_ANISOTROPIC;
             break;
 
 
 
-            // Maximum filters
-            case FILTER_TYPE_MAXIMUM_POINT:
-                if( MagFilter == FILTER_TYPE_MAXIMUM_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_MAXIMUM_POINT )
-                        return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                        return D3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_MAXIMUM_POINT )
-	                    return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                        return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR;
-                }
+        // Maximum filters
+        case FILTER_TYPE_MAXIMUM_POINT:
+            if (MagFilter == FILTER_TYPE_MAXIMUM_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_MAXIMUM_POINT)
+                    return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+                    return D3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_MAXIMUM_POINT)
+                    return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+                    return D3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_MAXIMUM_LINEAR:
-                if( MagFilter == FILTER_TYPE_MAXIMUM_POINT )
-                {
-                    if( MipFilter == FILTER_TYPE_MAXIMUM_POINT )
-                        return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                        return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
-                }
-                else if( MagFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                {
-                    if( MipFilter == FILTER_TYPE_MAXIMUM_POINT )
-	                    return D3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT;
-                    else if( MipFilter == FILTER_TYPE_MAXIMUM_LINEAR )
-                        return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR;
-                }
+        case FILTER_TYPE_MAXIMUM_LINEAR:
+            if (MagFilter == FILTER_TYPE_MAXIMUM_POINT)
+            {
+                if (MipFilter == FILTER_TYPE_MAXIMUM_POINT)
+                    return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+                    return D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+            }
+            else if (MagFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+            {
+                if (MipFilter == FILTER_TYPE_MAXIMUM_POINT)
+                    return D3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT;
+                else if (MipFilter == FILTER_TYPE_MAXIMUM_LINEAR)
+                    return D3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR;
+            }
             break;
 
-            case FILTER_TYPE_MAXIMUM_ANISOTROPIC:
-                VERIFY( MagFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC,
-                        "For maximum anistropic filtering, all filters must be anisotropic" );
-                return D3D_FILTER_MAXIMUM_ANISOTROPIC;
+        case FILTER_TYPE_MAXIMUM_ANISOTROPIC:
+            VERIFY(MagFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC && MipFilter == FILTER_TYPE_MAXIMUM_ANISOTROPIC,
+                   "For maximum anistropic filtering, all filters must be anisotropic");
+            return D3D_FILTER_MAXIMUM_ANISOTROPIC;
             break;
-        }
-
-	    UNEXPECTED( "Unsupported filter combination" );
-        return D3D_FILTER_MIN_MAG_MIP_POINT;
     }
+
+    UNEXPECTED("Unsupported filter combination");
+    return D3D_FILTER_MIN_MAG_MIP_POINT;
 }
+
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h b/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h
index eafa500c..13b4fcfb 100644
--- a/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h
+++ b/Graphics/GraphicsEngineD3DBase/include/D3DViewDescConversionImpl.h
@@ -32,307 +32,309 @@
 
 namespace Diligent
 {
-    template<typename D3D_SHADER_RESOURCE_VIEW_DESC>
-    void TextureViewDesc_to_D3D_SRV_DESC(const TextureViewDesc& SRVDesc, D3D_SHADER_RESOURCE_VIEW_DESC &d3dSRVDesc, Uint32 SampleCount)
+
+template <typename D3D_SHADER_RESOURCE_VIEW_DESC>
+void TextureViewDesc_to_D3D_SRV_DESC(const TextureViewDesc& SRVDesc, D3D_SHADER_RESOURCE_VIEW_DESC& d3dSRVDesc, Uint32 SampleCount)
+{
+    memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc));
+    d3dSRVDesc.Format = TexFormatToDXGI_Format(SRVDesc.Format, BIND_SHADER_RESOURCE);
+
+    switch (SRVDesc.TextureDim)
     {
-        memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc));
-        d3dSRVDesc.Format = TexFormatToDXGI_Format(SRVDesc.Format, BIND_SHADER_RESOURCE);
-
-        switch (SRVDesc.TextureDim)
-        {
-            case RESOURCE_DIM_TEX_1D:
-                d3dSRVDesc.ViewDimension             = D3D_SRV_DIMENSION_TEXTURE1D;
-                d3dSRVDesc.Texture1D.MipLevels       = SRVDesc.NumMipLevels;
-                d3dSRVDesc.Texture1D.MostDetailedMip = SRVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D:
+            d3dSRVDesc.ViewDimension             = D3D_SRV_DIMENSION_TEXTURE1D;
+            d3dSRVDesc.Texture1D.MipLevels       = SRVDesc.NumMipLevels;
+            d3dSRVDesc.Texture1D.MostDetailedMip = SRVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_1D_ARRAY:
-                d3dSRVDesc.ViewDimension                  = D3D_SRV_DIMENSION_TEXTURE1DARRAY;
-                d3dSRVDesc.Texture1DArray.ArraySize       = SRVDesc.NumArraySlices;
-                d3dSRVDesc.Texture1DArray.FirstArraySlice = SRVDesc.FirstArraySlice;
-                d3dSRVDesc.Texture1DArray.MipLevels       = SRVDesc.NumMipLevels;
-                d3dSRVDesc.Texture1DArray.MostDetailedMip = SRVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D_ARRAY:
+            d3dSRVDesc.ViewDimension                  = D3D_SRV_DIMENSION_TEXTURE1DARRAY;
+            d3dSRVDesc.Texture1DArray.ArraySize       = SRVDesc.NumArraySlices;
+            d3dSRVDesc.Texture1DArray.FirstArraySlice = SRVDesc.FirstArraySlice;
+            d3dSRVDesc.Texture1DArray.MipLevels       = SRVDesc.NumMipLevels;
+            d3dSRVDesc.Texture1DArray.MostDetailedMip = SRVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_2D:
-                if( SampleCount > 1 )
-                {
-                    d3dSRVDesc.ViewDimension =  D3D_SRV_DIMENSION_TEXTURE2DMS;
-                    d3dSRVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
-                }
-                else
-                {
-                    d3dSRVDesc.ViewDimension             =  D3D_SRV_DIMENSION_TEXTURE2D;
-                    d3dSRVDesc.Texture2D.MipLevels       = SRVDesc.NumMipLevels;
-                    d3dSRVDesc.Texture2D.MostDetailedMip = SRVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D:
+            if (SampleCount > 1)
+            {
+                d3dSRVDesc.ViewDimension                           = D3D_SRV_DIMENSION_TEXTURE2DMS;
+                d3dSRVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
+            }
+            else
+            {
+                d3dSRVDesc.ViewDimension             = D3D_SRV_DIMENSION_TEXTURE2D;
+                d3dSRVDesc.Texture2D.MipLevels       = SRVDesc.NumMipLevels;
+                d3dSRVDesc.Texture2D.MostDetailedMip = SRVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_2D_ARRAY:
-                if( SampleCount > 1 )
-                {
-                    d3dSRVDesc.ViewDimension                    =  D3D_SRV_DIMENSION_TEXTURE2DMSARRAY;
-                    d3dSRVDesc.Texture2DMSArray.ArraySize       = SRVDesc.NumArraySlices;
-                    d3dSRVDesc.Texture2DMSArray.FirstArraySlice = SRVDesc.FirstArraySlice;
-                }
-                else
-                {
-                    d3dSRVDesc.ViewDimension                  =  D3D_SRV_DIMENSION_TEXTURE2DARRAY;
-                    d3dSRVDesc.Texture2DArray.ArraySize       = SRVDesc.NumArraySlices;
-                    d3dSRVDesc.Texture2DArray.FirstArraySlice = SRVDesc.FirstArraySlice;
-                    d3dSRVDesc.Texture2DArray.MipLevels       = SRVDesc.NumMipLevels;
-                    d3dSRVDesc.Texture2DArray.MostDetailedMip = SRVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D_ARRAY:
+            if (SampleCount > 1)
+            {
+                d3dSRVDesc.ViewDimension                    = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY;
+                d3dSRVDesc.Texture2DMSArray.ArraySize       = SRVDesc.NumArraySlices;
+                d3dSRVDesc.Texture2DMSArray.FirstArraySlice = SRVDesc.FirstArraySlice;
+            }
+            else
+            {
+                d3dSRVDesc.ViewDimension                  = D3D_SRV_DIMENSION_TEXTURE2DARRAY;
+                d3dSRVDesc.Texture2DArray.ArraySize       = SRVDesc.NumArraySlices;
+                d3dSRVDesc.Texture2DArray.FirstArraySlice = SRVDesc.FirstArraySlice;
+                d3dSRVDesc.Texture2DArray.MipLevels       = SRVDesc.NumMipLevels;
+                d3dSRVDesc.Texture2DArray.MostDetailedMip = SRVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_3D:
-                d3dSRVDesc.ViewDimension             =  D3D_SRV_DIMENSION_TEXTURE3D;
-                d3dSRVDesc.Texture3D.MipLevels       = SRVDesc.NumMipLevels;
-                d3dSRVDesc.Texture3D.MostDetailedMip = SRVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_3D:
+            d3dSRVDesc.ViewDimension             = D3D_SRV_DIMENSION_TEXTURE3D;
+            d3dSRVDesc.Texture3D.MipLevels       = SRVDesc.NumMipLevels;
+            d3dSRVDesc.Texture3D.MostDetailedMip = SRVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_CUBE:
-                d3dSRVDesc.ViewDimension               =  D3D_SRV_DIMENSION_TEXTURECUBE;
-                d3dSRVDesc.TextureCube.MipLevels       = SRVDesc.NumMipLevels;
-                d3dSRVDesc.TextureCube.MostDetailedMip = SRVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_CUBE:
+            d3dSRVDesc.ViewDimension               = D3D_SRV_DIMENSION_TEXTURECUBE;
+            d3dSRVDesc.TextureCube.MipLevels       = SRVDesc.NumMipLevels;
+            d3dSRVDesc.TextureCube.MostDetailedMip = SRVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_CUBE_ARRAY:
-                d3dSRVDesc.ViewDimension                     = D3D_SRV_DIMENSION_TEXTURECUBEARRAY;
-                d3dSRVDesc.TextureCubeArray.MipLevels        = SRVDesc.NumMipLevels;
-                d3dSRVDesc.TextureCubeArray.MostDetailedMip  = SRVDesc.MostDetailedMip;
-                d3dSRVDesc.TextureCubeArray.First2DArrayFace = SRVDesc.FirstArraySlice;
-                d3dSRVDesc.TextureCubeArray.NumCubes         = SRVDesc.NumArraySlices / 6;
+        case RESOURCE_DIM_TEX_CUBE_ARRAY:
+            d3dSRVDesc.ViewDimension                     = D3D_SRV_DIMENSION_TEXTURECUBEARRAY;
+            d3dSRVDesc.TextureCubeArray.MipLevels        = SRVDesc.NumMipLevels;
+            d3dSRVDesc.TextureCubeArray.MostDetailedMip  = SRVDesc.MostDetailedMip;
+            d3dSRVDesc.TextureCubeArray.First2DArrayFace = SRVDesc.FirstArraySlice;
+            d3dSRVDesc.TextureCubeArray.NumCubes         = SRVDesc.NumArraySlices / 6;
             break;
 
-            default:
-                UNEXPECTED( "Unexpected view type" );
-        }
+        default:
+            UNEXPECTED("Unexpected view type");
     }
+}
 
-    template<typename D3D_RENDER_TARGET_VIEW_DESC>
-    void TextureViewDesc_to_D3D_RTV_DESC(const TextureViewDesc& RTVDesc, D3D_RENDER_TARGET_VIEW_DESC &d3dRTVDesc, Uint32 SampleCount)
+template <typename D3D_RENDER_TARGET_VIEW_DESC>
+void TextureViewDesc_to_D3D_RTV_DESC(const TextureViewDesc& RTVDesc, D3D_RENDER_TARGET_VIEW_DESC& d3dRTVDesc, Uint32 SampleCount)
+{
+    memset(&d3dRTVDesc, 0, sizeof(d3dRTVDesc));
+    d3dRTVDesc.Format = TexFormatToDXGI_Format(RTVDesc.Format, BIND_RENDER_TARGET);
+
+    switch (RTVDesc.TextureDim)
     {
-        memset(&d3dRTVDesc, 0, sizeof(d3dRTVDesc));
-        d3dRTVDesc.Format = TexFormatToDXGI_Format(RTVDesc.Format, BIND_RENDER_TARGET);
-
-        switch(RTVDesc.TextureDim)
-        {
-            case RESOURCE_DIM_TEX_1D:
-                d3dRTVDesc.ViewDimension      = D3D_RTV_DIMENSION_TEXTURE1D;
-                d3dRTVDesc.Texture1D.MipSlice = RTVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D:
+            d3dRTVDesc.ViewDimension      = D3D_RTV_DIMENSION_TEXTURE1D;
+            d3dRTVDesc.Texture1D.MipSlice = RTVDesc.MostDetailedMip;
             break;
-        
-            case RESOURCE_DIM_TEX_1D_ARRAY:
-                d3dRTVDesc.ViewDimension =  D3D_RTV_DIMENSION_TEXTURE1DARRAY;
-                d3dRTVDesc.Texture1DArray.ArraySize       = RTVDesc.NumArraySlices;
-                d3dRTVDesc.Texture1DArray.FirstArraySlice = RTVDesc.FirstArraySlice;
-                d3dRTVDesc.Texture1DArray.MipSlice        = RTVDesc.MostDetailedMip;
+
+        case RESOURCE_DIM_TEX_1D_ARRAY:
+            d3dRTVDesc.ViewDimension                  = D3D_RTV_DIMENSION_TEXTURE1DARRAY;
+            d3dRTVDesc.Texture1DArray.ArraySize       = RTVDesc.NumArraySlices;
+            d3dRTVDesc.Texture1DArray.FirstArraySlice = RTVDesc.FirstArraySlice;
+            d3dRTVDesc.Texture1DArray.MipSlice        = RTVDesc.MostDetailedMip;
             break;
 
 
-            case RESOURCE_DIM_TEX_2D:
-                if( SampleCount > 1 )
-                {
-                    d3dRTVDesc.ViewDimension = D3D_RTV_DIMENSION_TEXTURE2DMS;
-                    d3dRTVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
-                }
-                else
-                {
-                    d3dRTVDesc.ViewDimension      = D3D_RTV_DIMENSION_TEXTURE2D;
-                    d3dRTVDesc.Texture2D.MipSlice = RTVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D:
+            if (SampleCount > 1)
+            {
+                d3dRTVDesc.ViewDimension                           = D3D_RTV_DIMENSION_TEXTURE2DMS;
+                d3dRTVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
+            }
+            else
+            {
+                d3dRTVDesc.ViewDimension      = D3D_RTV_DIMENSION_TEXTURE2D;
+                d3dRTVDesc.Texture2D.MipSlice = RTVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_2D_ARRAY:
-                if( SampleCount > 1 )
-                {
-                    d3dRTVDesc.ViewDimension =  D3D_RTV_DIMENSION_TEXTURE2DMSARRAY;
-                    d3dRTVDesc.Texture2DMSArray.ArraySize = RTVDesc.NumArraySlices;
-                    d3dRTVDesc.Texture2DMSArray.FirstArraySlice = RTVDesc.FirstArraySlice;
-                }
-                else
-                {
-                    d3dRTVDesc.ViewDimension                  =  D3D_RTV_DIMENSION_TEXTURE2DARRAY;
-                    d3dRTVDesc.Texture2DArray.ArraySize       = RTVDesc.NumArraySlices;
-                    d3dRTVDesc.Texture2DArray.FirstArraySlice = RTVDesc.FirstArraySlice;
-                    d3dRTVDesc.Texture2DArray.MipSlice        = RTVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D_ARRAY:
+            if (SampleCount > 1)
+            {
+                d3dRTVDesc.ViewDimension                    = D3D_RTV_DIMENSION_TEXTURE2DMSARRAY;
+                d3dRTVDesc.Texture2DMSArray.ArraySize       = RTVDesc.NumArraySlices;
+                d3dRTVDesc.Texture2DMSArray.FirstArraySlice = RTVDesc.FirstArraySlice;
+            }
+            else
+            {
+                d3dRTVDesc.ViewDimension                  = D3D_RTV_DIMENSION_TEXTURE2DARRAY;
+                d3dRTVDesc.Texture2DArray.ArraySize       = RTVDesc.NumArraySlices;
+                d3dRTVDesc.Texture2DArray.FirstArraySlice = RTVDesc.FirstArraySlice;
+                d3dRTVDesc.Texture2DArray.MipSlice        = RTVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_3D:
-                d3dRTVDesc.ViewDimension         = D3D_RTV_DIMENSION_TEXTURE3D;
-                d3dRTVDesc.Texture3D.FirstWSlice = RTVDesc.FirstDepthSlice;
-                d3dRTVDesc.Texture3D.WSize       = RTVDesc.NumDepthSlices;
-                d3dRTVDesc.Texture3D.MipSlice    = RTVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_3D:
+            d3dRTVDesc.ViewDimension         = D3D_RTV_DIMENSION_TEXTURE3D;
+            d3dRTVDesc.Texture3D.FirstWSlice = RTVDesc.FirstDepthSlice;
+            d3dRTVDesc.Texture3D.WSize       = RTVDesc.NumDepthSlices;
+            d3dRTVDesc.Texture3D.MipSlice    = RTVDesc.MostDetailedMip;
             break;
 
-            default:
-                UNEXPECTED( "Unexpected view type" );
-        }
+        default:
+            UNEXPECTED("Unexpected view type");
     }
+}
+
+template <typename D3D_DEPTH_STENCIL_VIEW_DESC>
+void TextureViewDesc_to_D3D_DSV_DESC(const TextureViewDesc& DSVDesc, D3D_DEPTH_STENCIL_VIEW_DESC& d3dDSVDesc, Uint32 SampleCount)
+{
+    memset(&d3dDSVDesc, 0, sizeof(d3dDSVDesc));
+    d3dDSVDesc.Format = TexFormatToDXGI_Format(DSVDesc.Format, BIND_DEPTH_STENCIL);
 
-    template<typename D3D_DEPTH_STENCIL_VIEW_DESC>
-    void TextureViewDesc_to_D3D_DSV_DESC(const TextureViewDesc& DSVDesc, D3D_DEPTH_STENCIL_VIEW_DESC &d3dDSVDesc, Uint32 SampleCount)
+    switch (DSVDesc.TextureDim)
     {
-        memset(&d3dDSVDesc, 0, sizeof(d3dDSVDesc));
-        d3dDSVDesc.Format = TexFormatToDXGI_Format(DSVDesc.Format, BIND_DEPTH_STENCIL);
-
-        switch(DSVDesc.TextureDim)
-        {
-            case RESOURCE_DIM_TEX_1D:
-                d3dDSVDesc.ViewDimension      = D3D_DSV_DIMENSION_TEXTURE1D;
-                d3dDSVDesc.Texture1D.MipSlice = DSVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D:
+            d3dDSVDesc.ViewDimension      = D3D_DSV_DIMENSION_TEXTURE1D;
+            d3dDSVDesc.Texture1D.MipSlice = DSVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_1D_ARRAY:
-                d3dDSVDesc.ViewDimension                  = D3D_DSV_DIMENSION_TEXTURE1DARRAY;
-                d3dDSVDesc.Texture1DArray.ArraySize       = DSVDesc.NumArraySlices;
-                d3dDSVDesc.Texture1DArray.FirstArraySlice = DSVDesc.FirstArraySlice;
-                d3dDSVDesc.Texture1DArray.MipSlice        = DSVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D_ARRAY:
+            d3dDSVDesc.ViewDimension                  = D3D_DSV_DIMENSION_TEXTURE1DARRAY;
+            d3dDSVDesc.Texture1DArray.ArraySize       = DSVDesc.NumArraySlices;
+            d3dDSVDesc.Texture1DArray.FirstArraySlice = DSVDesc.FirstArraySlice;
+            d3dDSVDesc.Texture1DArray.MipSlice        = DSVDesc.MostDetailedMip;
             break;
 
 
-            case RESOURCE_DIM_TEX_2D:
-                if( SampleCount > 1 )
-                {
-                    d3dDSVDesc.ViewDimension = D3D_DSV_DIMENSION_TEXTURE2DMS;
-                    d3dDSVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
-                }
-                else
-                {
-                    d3dDSVDesc.ViewDimension      = D3D_DSV_DIMENSION_TEXTURE2D;
-                    d3dDSVDesc.Texture2D.MipSlice = DSVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D:
+            if (SampleCount > 1)
+            {
+                d3dDSVDesc.ViewDimension                           = D3D_DSV_DIMENSION_TEXTURE2DMS;
+                d3dDSVDesc.Texture2DMS.UnusedField_NothingToDefine = 0;
+            }
+            else
+            {
+                d3dDSVDesc.ViewDimension      = D3D_DSV_DIMENSION_TEXTURE2D;
+                d3dDSVDesc.Texture2D.MipSlice = DSVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_2D_ARRAY:
-                if( SampleCount > 1 )
-                {
-                    d3dDSVDesc.ViewDimension                    = D3D_DSV_DIMENSION_TEXTURE2DMSARRAY;
-                    d3dDSVDesc.Texture2DMSArray.ArraySize       = DSVDesc.NumArraySlices;
-                    d3dDSVDesc.Texture2DMSArray.FirstArraySlice = DSVDesc.FirstArraySlice;
-                }
-                else
-                {
-                    d3dDSVDesc.ViewDimension                  = D3D_DSV_DIMENSION_TEXTURE2DARRAY;
-                    d3dDSVDesc.Texture2DArray.ArraySize       = DSVDesc.NumArraySlices;
-                    d3dDSVDesc.Texture2DArray.FirstArraySlice = DSVDesc.FirstArraySlice;
-                    d3dDSVDesc.Texture2DArray.MipSlice        = DSVDesc.MostDetailedMip;
-                }
+        case RESOURCE_DIM_TEX_2D_ARRAY:
+            if (SampleCount > 1)
+            {
+                d3dDSVDesc.ViewDimension                    = D3D_DSV_DIMENSION_TEXTURE2DMSARRAY;
+                d3dDSVDesc.Texture2DMSArray.ArraySize       = DSVDesc.NumArraySlices;
+                d3dDSVDesc.Texture2DMSArray.FirstArraySlice = DSVDesc.FirstArraySlice;
+            }
+            else
+            {
+                d3dDSVDesc.ViewDimension                  = D3D_DSV_DIMENSION_TEXTURE2DARRAY;
+                d3dDSVDesc.Texture2DArray.ArraySize       = DSVDesc.NumArraySlices;
+                d3dDSVDesc.Texture2DArray.FirstArraySlice = DSVDesc.FirstArraySlice;
+                d3dDSVDesc.Texture2DArray.MipSlice        = DSVDesc.MostDetailedMip;
+            }
             break;
 
-            case RESOURCE_DIM_TEX_3D:
-                LOG_ERROR_AND_THROW("Depth stencil views are not supported for 3D textures");
+        case RESOURCE_DIM_TEX_3D:
+            LOG_ERROR_AND_THROW("Depth stencil views are not supported for 3D textures");
             break;
 
-            default:
-                UNEXPECTED( "Unexpected view type" );
-        }
+        default:
+            UNEXPECTED("Unexpected view type");
     }
+}
 
-    template<typename D3D_UNORDERED_ACCESS_VIEW_DESC>
-    void TextureViewDesc_to_D3D_UAV_DESC(const TextureViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC &d3dUAVDesc)
+template <typename D3D_UNORDERED_ACCESS_VIEW_DESC>
+void TextureViewDesc_to_D3D_UAV_DESC(const TextureViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc)
+{
+    memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc));
+    d3dUAVDesc.Format = TexFormatToDXGI_Format(UAVDesc.Format, BIND_UNORDERED_ACCESS);
+
+    switch (UAVDesc.TextureDim)
     {
-        memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc));
-        d3dUAVDesc.Format = TexFormatToDXGI_Format(UAVDesc.Format, BIND_UNORDERED_ACCESS);
-
-        switch(UAVDesc.TextureDim)
-        {
-            case RESOURCE_DIM_TEX_1D:
-                d3dUAVDesc.ViewDimension      = D3D_UAV_DIMENSION_TEXTURE1D;
-                d3dUAVDesc.Texture1D.MipSlice = UAVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D:
+            d3dUAVDesc.ViewDimension      = D3D_UAV_DIMENSION_TEXTURE1D;
+            d3dUAVDesc.Texture1D.MipSlice = UAVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_1D_ARRAY:
-                d3dUAVDesc.ViewDimension                  = D3D_UAV_DIMENSION_TEXTURE1DARRAY;
-                d3dUAVDesc.Texture1DArray.ArraySize       = UAVDesc.NumArraySlices;
-                d3dUAVDesc.Texture1DArray.FirstArraySlice = UAVDesc.FirstArraySlice;
-                d3dUAVDesc.Texture1DArray.MipSlice        = UAVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_1D_ARRAY:
+            d3dUAVDesc.ViewDimension                  = D3D_UAV_DIMENSION_TEXTURE1DARRAY;
+            d3dUAVDesc.Texture1DArray.ArraySize       = UAVDesc.NumArraySlices;
+            d3dUAVDesc.Texture1DArray.FirstArraySlice = UAVDesc.FirstArraySlice;
+            d3dUAVDesc.Texture1DArray.MipSlice        = UAVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_2D:
-                d3dUAVDesc.ViewDimension      = D3D_UAV_DIMENSION_TEXTURE2D;
-                d3dUAVDesc.Texture2D.MipSlice = UAVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_2D:
+            d3dUAVDesc.ViewDimension      = D3D_UAV_DIMENSION_TEXTURE2D;
+            d3dUAVDesc.Texture2D.MipSlice = UAVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_2D_ARRAY:
-                d3dUAVDesc.ViewDimension                  = D3D_UAV_DIMENSION_TEXTURE2DARRAY;
-                d3dUAVDesc.Texture2DArray.ArraySize       = UAVDesc.NumArraySlices;
-                d3dUAVDesc.Texture2DArray.FirstArraySlice = UAVDesc.FirstArraySlice;
-                d3dUAVDesc.Texture2DArray.MipSlice        = UAVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_2D_ARRAY:
+            d3dUAVDesc.ViewDimension                  = D3D_UAV_DIMENSION_TEXTURE2DARRAY;
+            d3dUAVDesc.Texture2DArray.ArraySize       = UAVDesc.NumArraySlices;
+            d3dUAVDesc.Texture2DArray.FirstArraySlice = UAVDesc.FirstArraySlice;
+            d3dUAVDesc.Texture2DArray.MipSlice        = UAVDesc.MostDetailedMip;
             break;
 
-            case RESOURCE_DIM_TEX_3D:
-                d3dUAVDesc.ViewDimension         = D3D_UAV_DIMENSION_TEXTURE3D;
-                d3dUAVDesc.Texture3D.FirstWSlice = UAVDesc.FirstDepthSlice;
-                d3dUAVDesc.Texture3D.WSize       = UAVDesc.NumDepthSlices;
-                d3dUAVDesc.Texture3D.MipSlice    = UAVDesc.MostDetailedMip;
+        case RESOURCE_DIM_TEX_3D:
+            d3dUAVDesc.ViewDimension         = D3D_UAV_DIMENSION_TEXTURE3D;
+            d3dUAVDesc.Texture3D.FirstWSlice = UAVDesc.FirstDepthSlice;
+            d3dUAVDesc.Texture3D.WSize       = UAVDesc.NumDepthSlices;
+            d3dUAVDesc.Texture3D.MipSlice    = UAVDesc.MostDetailedMip;
             break;
 
-            default:
-                UNEXPECTED( "Unexpected view type" );
-        }
+        default:
+            UNEXPECTED("Unexpected view type");
+    }
+}
+
+template <typename D3D_UNORDERED_ACCESS_VIEW_DESC>
+void BufferViewDesc_to_D3D_SRV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& SRVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dSRVDesc)
+{
+    VERIFY(SRVDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE, "Incorrect view type: shader resource is expected");
+
+    memset(&d3dSRVDesc, 0, sizeof(d3dSRVDesc));
+    const auto& BuffFmt = SRVDesc.Format;
+    if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
+        d3dSRVDesc.Format = TypeToDXGI_Format(BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized);
+
+    Uint32 ElementByteStride = 0;
+    if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
+        ElementByteStride = BuffDesc.ElementByteStride;
+    else if (BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED)
+        ElementByteStride = 4;
+
+    if (ElementByteStride != 0)
+    {
+        DEV_CHECK_ERR((SRVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", SRVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")");
+        DEV_CHECK_ERR((SRVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", SRVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")");
+        d3dSRVDesc.Buffer.FirstElement = SRVDesc.ByteOffset / ElementByteStride;
+        d3dSRVDesc.Buffer.NumElements  = SRVDesc.ByteWidth / ElementByteStride;
     }
+    d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_BUFFER;
+}
+
+template <typename D3D_UNORDERED_ACCESS_VIEW_DESC>
+void BufferViewDesc_to_D3D_UAV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc)
+{
+    VERIFY(UAVDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS, "Incorrect view type: unordered access is expected");
+
+    memset(&d3dUAVDesc, 0, sizeof(d3dUAVDesc));
+    const auto& BuffFmt = UAVDesc.Format;
+    if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
+        d3dUAVDesc.Format = TypeToDXGI_Format(BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized);
 
-    template<typename D3D_UNORDERED_ACCESS_VIEW_DESC>
-    void BufferViewDesc_to_D3D_SRV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& SRVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dSRVDesc)
+    Uint32 ElementByteStride = 0;
+    if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
+        ElementByteStride = BuffDesc.ElementByteStride;
+    else if (BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED)
+        ElementByteStride = 4;
+
+    if (ElementByteStride != 0)
     {
-        VERIFY(SRVDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE, "Incorrect view type: shader resource is expected" );
-
-        memset( &d3dSRVDesc, 0, sizeof( d3dSRVDesc ) );
-        const auto& BuffFmt = SRVDesc.Format;
-        if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
-            d3dSRVDesc.Format = TypeToDXGI_Format( BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized );
-        
-        Uint32 ElementByteStride = 0;
-        if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
-            ElementByteStride = BuffDesc.ElementByteStride;
-        else if(BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED)
-            ElementByteStride = 4;
-
-        if (ElementByteStride != 0)
-        {
-            DEV_CHECK_ERR( (SRVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", SRVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")" );
-            DEV_CHECK_ERR( (SRVDesc.ByteWidth % ElementByteStride)  == 0, "Byte width (", SRVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")" );
-            d3dSRVDesc.Buffer.FirstElement = SRVDesc.ByteOffset / ElementByteStride;
-            d3dSRVDesc.Buffer.NumElements  = SRVDesc.ByteWidth  / ElementByteStride;
-        }
-        d3dSRVDesc.ViewDimension = D3D_SRV_DIMENSION_BUFFER;
+        DEV_CHECK_ERR((UAVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", UAVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")");
+        DEV_CHECK_ERR((UAVDesc.ByteWidth % ElementByteStride) == 0, "Byte width (", UAVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")");
+        d3dUAVDesc.Buffer.FirstElement = UAVDesc.ByteOffset / ElementByteStride;
+        d3dUAVDesc.Buffer.NumElements  = UAVDesc.ByteWidth / ElementByteStride;
     }
 
-    template<typename D3D_UNORDERED_ACCESS_VIEW_DESC>
-    void BufferViewDesc_to_D3D_UAV_DESC(const BufferDesc& BuffDesc, const BufferViewDesc& UAVDesc, D3D_UNORDERED_ACCESS_VIEW_DESC& d3dUAVDesc)
+    if (BuffDesc.Mode == BUFFER_MODE_RAW && UAVDesc.Format.ValueType == VT_UNDEFINED)
     {
-        VERIFY(UAVDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS, "Incorrect view type: unordered access is expected");
-
-        memset( &d3dUAVDesc, 0, sizeof(d3dUAVDesc) );
-        const auto& BuffFmt = UAVDesc.Format;
-        if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
-            d3dUAVDesc.Format = TypeToDXGI_Format( BuffFmt.ValueType, BuffFmt.NumComponents, BuffFmt.IsNormalized );
-        
-        Uint32 ElementByteStride = 0;
-        if (BuffDesc.Mode == BUFFER_MODE_FORMATTED || BuffDesc.Mode == BUFFER_MODE_STRUCTURED || BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType != VT_UNDEFINED)
-            ElementByteStride = BuffDesc.ElementByteStride;
-        else if(BuffDesc.Mode == BUFFER_MODE_RAW && BuffFmt.ValueType == VT_UNDEFINED)
-            ElementByteStride = 4;
-
-        if (ElementByteStride != 0)
-        {
-            DEV_CHECK_ERR( (UAVDesc.ByteOffset % ElementByteStride) == 0, "Byte offest (", UAVDesc.ByteOffset, ") is not multiple of element byte stride (", ElementByteStride, ")" );
-            DEV_CHECK_ERR( (UAVDesc.ByteWidth % ElementByteStride)  == 0, "Byte width (", UAVDesc.ByteWidth, ")is not multiple of element byte stride (", ElementByteStride, ")" );
-            d3dUAVDesc.Buffer.FirstElement = UAVDesc.ByteOffset / ElementByteStride;
-            d3dUAVDesc.Buffer.NumElements  = UAVDesc.ByteWidth  / ElementByteStride;
-        }
-
-        if (BuffDesc.Mode == BUFFER_MODE_RAW && UAVDesc.Format.ValueType == VT_UNDEFINED)
-        {
-            d3dUAVDesc.Format       = DXGI_FORMAT_R32_TYPELESS;
-            d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_RAW;
-        }
-        else
-            d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_NONE;
-
-        d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_BUFFER;
+        d3dUAVDesc.Format       = DXGI_FORMAT_R32_TYPELESS;
+        d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_RAW;
     }
+    else
+        d3dUAVDesc.Buffer.Flags = D3D_BUFFER_UAV_FLAG_NONE;
+
+    d3dUAVDesc.ViewDimension = D3D_UAV_DIMENSION_BUFFER;
 }
+
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h b/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h
index 8d71f9c0..c1a972be 100644
--- a/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h
+++ b/Graphics/GraphicsEngineD3DBase/include/DXGITypeConversions.h
@@ -31,8 +31,7 @@
 
 namespace Diligent
 {
-    DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags = 0);
-    TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat);
-    DXGI_FORMAT TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized);
-}
-
+DXGI_FORMAT    TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags = 0);
+TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat);
+DXGI_FORMAT    TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized);
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h
index fac7683c..a13379a7 100644
--- a/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h
+++ b/Graphics/GraphicsEngineD3DBase/include/EngineFactoryD3DBase.h
@@ -32,20 +32,20 @@
 namespace Diligent
 {
 
-template<typename BaseInterface, DeviceType DevType>
+template <typename BaseInterface, DeviceType DevType>
 class EngineFactoryD3DBase : public EngineFactoryBase<BaseInterface>
 {
 public:
     using TEngineFactoryBase = EngineFactoryBase<BaseInterface>;
 
-    EngineFactoryD3DBase(const INTERFACE_ID& FactoryIID) : 
-        TEngineFactoryBase(FactoryIID)
+    EngineFactoryD3DBase(const INTERFACE_ID& FactoryIID) :
+        TEngineFactoryBase{FactoryIID}
     {}
 
 
-    virtual void EnumerateHardwareAdapters(DIRECT3D_FEATURE_LEVEL   MinFeatureLevel,
-                                           Uint32&                  NumAdapters, 
-                                           HardwareAdapterAttribs*  Adapters)override final
+    virtual void EnumerateHardwareAdapters(DIRECT3D_FEATURE_LEVEL  MinFeatureLevel,
+                                           Uint32&                 NumAdapters,
+                                           HardwareAdapterAttribs* Adapters) override final
     {
         auto DXGIAdapters = FindCompatibleAdapters(MinFeatureLevel);
 
@@ -56,17 +56,17 @@ public:
             NumAdapters = std::min(NumAdapters, static_cast<Uint32>(DXGIAdapters.size()));
             for (Uint32 adapter = 0; adapter < NumAdapters; ++adapter)
             {
-                IDXGIAdapter1 *pDXIAdapter = DXGIAdapters[adapter];
+                IDXGIAdapter1*     pDXIAdapter = DXGIAdapters[adapter];
                 DXGI_ADAPTER_DESC1 AdapterDesc;
                 pDXIAdapter->GetDesc1(&AdapterDesc);
 
-                auto &Attribs = Adapters[adapter];
+                auto& Attribs = Adapters[adapter];
                 WideCharToMultiByte(CP_ACP, 0, AdapterDesc.Description, -1, Attribs.Description, _countof(Attribs.Description), NULL, FALSE);
-                Attribs.DedicatedVideoMemory = AdapterDesc.DedicatedVideoMemory;
+                Attribs.DedicatedVideoMemory  = AdapterDesc.DedicatedVideoMemory;
                 Attribs.DedicatedSystemMemory = AdapterDesc.DedicatedSystemMemory;
-                Attribs.SharedSystemMemory = AdapterDesc.SharedSystemMemory;
-                Attribs.VendorId = AdapterDesc.VendorId;
-                Attribs.DeviceId = AdapterDesc.DeviceId;
+                Attribs.SharedSystemMemory    = AdapterDesc.SharedSystemMemory;
+                Attribs.VendorId              = AdapterDesc.VendorId;
+                Attribs.DeviceId              = AdapterDesc.DeviceId;
 
                 Attribs.NumOutputs = 0;
                 CComPtr<IDXGIOutput> pOutput;
@@ -81,22 +81,22 @@ public:
 
 
     virtual void EnumerateDisplayModes(DIRECT3D_FEATURE_LEVEL MinFeatureLevel,
-                                       Uint32                 AdapterId, 
+                                       Uint32                 AdapterId,
                                        Uint32                 OutputId,
-                                       TEXTURE_FORMAT         Format, 
-                                       Uint32&                NumDisplayModes, 
-                                       DisplayModeAttribs*    DisplayModes)override final
+                                       TEXTURE_FORMAT         Format,
+                                       Uint32&                NumDisplayModes,
+                                       DisplayModeAttribs*    DisplayModes) override final
     {
         auto DXGIAdapters = FindCompatibleAdapters(MinFeatureLevel);
-        if(AdapterId >= DXGIAdapters.size())
+        if (AdapterId >= DXGIAdapters.size())
         {
             LOG_ERROR("Incorrect adapter id ", AdapterId);
             return;
         }
 
-        IDXGIAdapter1 *pDXIAdapter = DXGIAdapters[AdapterId];
+        IDXGIAdapter1* pDXIAdapter = DXGIAdapters[AdapterId];
 
-        DXGI_FORMAT DXIGFormat = TexFormatToDXGI_Format(Format);
+        DXGI_FORMAT          DXIGFormat = TexFormatToDXGI_Format(Format);
         CComPtr<IDXGIOutput> pOutput;
         if (pDXIAdapter->EnumOutputs(OutputId, &pOutput) == DXGI_ERROR_NOT_FOUND)
         {
@@ -118,15 +118,15 @@ public:
             hr = pOutput->GetDisplayModeList(DXIGFormat, 0, &numModes, DXIDisplayModes.data());
             for (Uint32 m = 0; m < std::min(NumDisplayModes, numModes); ++m)
             {
-                const auto &SrcMode = DXIDisplayModes[m];
-                auto &DstMode = DisplayModes[m];
-                DstMode.Width = SrcMode.Width;
-                DstMode.Height = SrcMode.Height;
-                DstMode.Format = DXGI_FormatToTexFormat(SrcMode.Format);
-                DstMode.RefreshRateNumerator = SrcMode.RefreshRate.Numerator;
+                const auto& SrcMode            = DXIDisplayModes[m];
+                auto&       DstMode            = DisplayModes[m];
+                DstMode.Width                  = SrcMode.Width;
+                DstMode.Height                 = SrcMode.Height;
+                DstMode.Format                 = DXGI_FormatToTexFormat(SrcMode.Format);
+                DstMode.RefreshRateNumerator   = SrcMode.RefreshRate.Numerator;
                 DstMode.RefreshRateDenominator = SrcMode.RefreshRate.Denominator;
-                DstMode.Scaling = static_cast<DisplayModeAttribs::SCALING>(SrcMode.Scaling);
-                DstMode.ScanlineOrder = static_cast<DisplayModeAttribs::SCANLINE_ORDER>(SrcMode.ScanlineOrdering);
+                DstMode.Scaling                = static_cast<DisplayModeAttribs::SCALING>(SrcMode.Scaling);
+                DstMode.ScanlineOrder          = static_cast<DisplayModeAttribs::SCANLINE_ORDER>(SrcMode.ScanlineOrdering);
             }
             NumDisplayModes = std::min(NumDisplayModes, numModes);
         }
@@ -148,9 +148,9 @@ public:
             return std::move(DXGIAdapters);
         }
 
-        auto d3dFeatureLevel = GetD3DFeatureLevel(MinFeatureLevel);
+        auto                   d3dFeatureLevel = GetD3DFeatureLevel(MinFeatureLevel);
         CComPtr<IDXGIAdapter1> pDXIAdapter;
-        UINT adapter = 0;
+        UINT                   adapter = 0;
         for (; pFactory->EnumAdapters1(adapter, &pDXIAdapter) != DXGI_ERROR_NOT_FOUND; ++adapter, pDXIAdapter.Release())
         {
             DXGI_ADAPTER_DESC1 AdapterDesc;
@@ -173,16 +173,15 @@ public:
 
 
 protected:
-
     static D3D_FEATURE_LEVEL GetD3DFeatureLevel(DIRECT3D_FEATURE_LEVEL FeatureLevel)
     {
-        switch(FeatureLevel)
+        switch (FeatureLevel)
         {
             case DIRECT3D_FEATURE_LEVEL_10_0: return D3D_FEATURE_LEVEL_10_0;
             case DIRECT3D_FEATURE_LEVEL_10_1: return D3D_FEATURE_LEVEL_10_1;
             case DIRECT3D_FEATURE_LEVEL_11_0: return D3D_FEATURE_LEVEL_11_0;
             case DIRECT3D_FEATURE_LEVEL_11_1: return D3D_FEATURE_LEVEL_11_1;
-#if defined(_WIN32_WINNT_WIN10) && (_WIN32_WINNT >=_WIN32_WINNT_WIN10)
+#if defined(_WIN32_WINNT_WIN10) && (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
             case DIRECT3D_FEATURE_LEVEL_12_0: return D3D_FEATURE_LEVEL_12_0;
             case DIRECT3D_FEATURE_LEVEL_12_1: return D3D_FEATURE_LEVEL_12_1;
 #endif
@@ -194,31 +193,30 @@ protected:
     }
 
 private:
-
-    template<DeviceType DevType>
+    template <DeviceType DevType>
     bool CheckAdapterCompatibility(IDXGIAdapter1*    pDXGIAdapter,
                                    D3D_FEATURE_LEVEL FeatureLevels);
 
-    template<>
+    template <>
     bool CheckAdapterCompatibility<DeviceType::D3D11>(IDXGIAdapter1*    pDXGIAdapter,
                                                       D3D_FEATURE_LEVEL FeatureLevel)
     {
-	    auto hr = D3D11CreateDevice(
-		    nullptr,
-		    D3D_DRIVER_TYPE_NULL,       // There is no need to create a real hardware device.
-		    0,
-		    0,                          // Flags.
-		    &FeatureLevel,              // Feature levels.
-		    1,                          // Number of feature levels
-		    D3D11_SDK_VERSION,          // Always set this to D3D11_SDK_VERSION for Windows Store apps.
-		    nullptr,                    // No need to keep the D3D device reference.
-		    nullptr,                    // Feature level of the created adapter.
-		    nullptr                     // No need to keep the D3D device context reference.
-		    );
-	    return SUCCEEDED(hr);
+        auto hr = D3D11CreateDevice(
+            nullptr,
+            D3D_DRIVER_TYPE_NULL, // There is no need to create a real hardware device.
+            0,
+            0,                 // Flags.
+            &FeatureLevel,     // Feature levels.
+            1,                 // Number of feature levels
+            D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION for Windows Store apps.
+            nullptr,           // No need to keep the D3D device reference.
+            nullptr,           // Feature level of the created adapter.
+            nullptr            // No need to keep the D3D device context reference.
+        );
+        return SUCCEEDED(hr);
     }
 
-    template<>
+    template <>
     bool CheckAdapterCompatibility<DeviceType::D3D12>(IDXGIAdapter1*    pDXGIAdapter,
                                                       D3D_FEATURE_LEVEL FeatureLevel)
     {
@@ -227,4 +225,4 @@ private:
     }
 };
 
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h
index af82ccac..b0ae8dcb 100644
--- a/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h
+++ b/Graphics/GraphicsEngineD3DBase/include/RenderDeviceD3DBase.h
@@ -33,19 +33,20 @@ namespace Diligent
 
 /// Base implementation of a D3D render device
 
-template<typename BaseInterface>
+template <typename BaseInterface>
 class RenderDeviceD3DBase : public RenderDeviceBase<BaseInterface>
 {
 public:
-    RenderDeviceD3DBase(IReferenceCounters*      pRefCounters, 
-                        IMemoryAllocator&        RawMemAllocator, 
+    RenderDeviceD3DBase(IReferenceCounters*      pRefCounters,
+                        IMemoryAllocator&        RawMemAllocator,
                         IEngineFactory*          pEngineFactory,
                         Uint32                   NumDeferredContexts,
-                        const DeviceObjectSizes& ObjectSizes) : 
-        RenderDeviceBase<BaseInterface>(pRefCounters, RawMemAllocator, pEngineFactory, NumDeferredContexts, ObjectSizes)
+                        const DeviceObjectSizes& ObjectSizes) :
+        RenderDeviceBase<BaseInterface>{pRefCounters, RawMemAllocator, pEngineFactory, NumDeferredContexts, ObjectSizes}
     {
         // Flag texture formats always supported in D3D11 and D3D12
 
+        // clang-format off
 #define FLAG_FORMAT(Fmt, IsSupported) m_TextureFormatsInfo[Fmt].Supported=IsSupported
 
         FLAG_FORMAT(TEX_FORMAT_RGBA32_TYPELESS,            true);
@@ -148,7 +149,8 @@ public:
         FLAG_FORMAT(TEX_FORMAT_BC7_UNORM,                  true);
         FLAG_FORMAT(TEX_FORMAT_BC7_UNORM_SRGB,             true);
 #undef FLAG_FORMAT
+        // clang-format on
     }
 };
 
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h
index c8c4de8f..17c86b6f 100644
--- a/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h
+++ b/Graphics/GraphicsEngineD3DBase/include/ShaderD3DBase.h
@@ -32,13 +32,15 @@
 
 namespace Diligent
 {
-    /// Base implementation of a D3D shader
-    class ShaderD3DBase
-    {
-    public:
-        ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel);
-
-    protected:
-        CComPtr<ID3DBlob> m_pShaderByteCode;
-    };
-}
+
+/// Base implementation of a D3D shader
+class ShaderD3DBase
+{
+public:
+    ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel);
+
+protected:
+    CComPtr<ID3DBlob> m_pShaderByteCode;
+};
+
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
index d15484a0..0e08c547 100644
--- a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
+++ b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
@@ -40,10 +40,10 @@
 //  Nbsrv - number of buffer SRVs
 //  Nbuav - number of buffer UAVs
 //  Nsam  - number of samplers
-//  
+//
 //
 //  If texture SRV is assigned a sampler, it is cross-referenced through SamplerOrTexSRVId:
-// 
+//
 //                           _____________________SamplerOrTexSRVId___________________
 //                          |                                                         |
 //                          |                                                         V
@@ -68,8 +68,10 @@ namespace Diligent
 {
 
 // sizeof(D3DShaderResourceAttribs) == 16 (x64)
-struct D3DShaderResourceAttribs 
+struct D3DShaderResourceAttribs
 {
+    // clang-format off
+
 /* 0 */ const char* const Name;
 
 /* 8 */ const Uint16 BindPoint;
@@ -97,6 +99,8 @@ private:
 /*13.0*/       Uint32  SamplerOrTexSRVId  : SamplerOrTexSRVIdBits;   // Max value: 2^24-1
 /*16  */ // End of structure
 
+    // clang-format on
+
 public:
     static constexpr const Uint32 InvalidSamplerId = (1 << SamplerOrTexSRVIdBits) - 1;
     static constexpr const Uint32 InvalidTexSRVId  = (1 << SamplerOrTexSRVIdBits) - 1;
@@ -105,25 +109,29 @@ public:
     static constexpr const Uint16 MaxBindCount     = std::numeric_limits<Uint16>::max();
 
 
-    D3DShaderResourceAttribs(const char*            _Name, 
-                             UINT                   _BindPoint, 
-                             UINT                   _BindCount, 
-                             D3D_SHADER_INPUT_TYPE  _InputType, 
-                             D3D_SRV_DIMENSION      _SRVDimension,
-                             Uint32                 _SamplerId)noexcept :
-        Name               (_Name),
-        BindPoint          (static_cast<decltype(BindPoint)>   (_BindPoint)),
-        BindCount          (static_cast<decltype(BindCount)>   (_BindCount)),
-        InputType          (static_cast<decltype(InputType)>   (_InputType)),
-        SRVDimension       (static_cast<decltype(SRVDimension)>(_SRVDimension)),
-        SamplerOrTexSRVId  (_SamplerId)
+    D3DShaderResourceAttribs(const char*           _Name,
+                             UINT                  _BindPoint,
+                             UINT                  _BindCount,
+                             D3D_SHADER_INPUT_TYPE _InputType,
+                             D3D_SRV_DIMENSION     _SRVDimension,
+                             Uint32                _SamplerId) noexcept :
+        // clang-format off
+        Name               {_Name},
+        BindPoint          {static_cast<decltype(BindPoint)>   (_BindPoint)   },
+        BindCount          {static_cast<decltype(BindCount)>   (_BindCount)   },
+        InputType          {static_cast<decltype(InputType)>   (_InputType)   },
+        SRVDimension       {static_cast<decltype(SRVDimension)>(_SRVDimension)},
+        SamplerOrTexSRVId  {_SamplerId}
+    // clang-format on
     {
 #ifdef _DEBUG
+        // clang-format off
         VERIFY(_BindPoint <= MaxBindPoint || _BindPoint == InvalidBindPoint, "Bind Point is out of allowed range");
         VERIFY(_BindCount <= MaxBindCount, "Bind Count is out of allowed range");
         VERIFY(_InputType    < (1 << ShaderInputTypeBits),   "Shader input type is out of expected range");
         VERIFY(_SRVDimension < (1 << SRVDimBits),            "SRV dimensions is out of expected range");
         VERIFY(_SamplerId    < (1 << SamplerOrTexSRVIdBits), "SamplerOrTexSRVId is out of representable range");
+        // clang-format on
 
         if (_InputType == D3D_SIT_TEXTURE && _SRVDimension != D3D_SRV_DIMENSION_BUFFER)
             VERIFY_EXPR(GetCombinedSamplerId() == _SamplerId);
@@ -132,7 +140,8 @@ public:
 #endif
     }
 
-    D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs, Uint32 SamplerId)noexcept : 
+    D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs, Uint32 SamplerId) noexcept :
+        // clang-format off
         D3DShaderResourceAttribs
         {
             NamesPool.CopyString(rhs.Name),
@@ -142,11 +151,13 @@ public:
             rhs.GetSRVDimension(),
             SamplerId
         }
+    // clang-format on
     {
         VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Only texture SRV can be assigned a texture sampler");
     }
 
-    D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs)noexcept : 
+    D3DShaderResourceAttribs(StringPool& NamesPool, const D3DShaderResourceAttribs& rhs) noexcept :
+        // clang-format off
         D3DShaderResourceAttribs
         {
             NamesPool.CopyString(rhs.Name),
@@ -156,105 +167,111 @@ public:
             rhs.GetSRVDimension(),
             rhs.SamplerOrTexSRVId
         }
+    // clang-format on
     {
     }
 
+    // clang-format off
     D3DShaderResourceAttribs             (const D3DShaderResourceAttribs&  rhs) = delete;
     D3DShaderResourceAttribs             (      D3DShaderResourceAttribs&& rhs) = default; // Required for vector<D3DShaderResourceAttribs>
     D3DShaderResourceAttribs& operator = (const D3DShaderResourceAttribs&  rhs) = delete;
     D3DShaderResourceAttribs& operator = (      D3DShaderResourceAttribs&& rhs) = delete;
-    
-    D3D_SHADER_INPUT_TYPE GetInputType()const
+    // clang-format on
+
+    D3D_SHADER_INPUT_TYPE GetInputType() const
     {
         return static_cast<D3D_SHADER_INPUT_TYPE>(InputType);
     }
 
-    D3D_SRV_DIMENSION GetSRVDimension()const
+    D3D_SRV_DIMENSION GetSRVDimension() const
     {
         return static_cast<D3D_SRV_DIMENSION>(SRVDimension);
     }
 
-    bool IsCombinedWithSampler()const
+    bool IsCombinedWithSampler() const
     {
         return GetCombinedSamplerId() != InvalidSamplerId;
     }
 
-    bool IsCombinedWithTexSRV()const
+    bool IsCombinedWithTexSRV() const
     {
         return GetCombinedTexSRVId() != InvalidTexSRVId;
     }
 
-    bool IsValidBindPoint()const
+    bool IsValidBindPoint() const
     {
         return BindPoint != InvalidBindPoint;
     }
 
-    String GetPrintName(Uint32 ArrayInd)const
+    String GetPrintName(Uint32 ArrayInd) const
     {
         VERIFY_EXPR(ArrayInd < BindCount);
-        if(BindCount > 1)
+        if (BindCount > 1)
             return String(Name) + '[' + std::to_string(ArrayInd) + ']';
         else
             return Name;
     }
 
-    bool IsCompatibleWith(const D3DShaderResourceAttribs& Attribs)const
+    bool IsCompatibleWith(const D3DShaderResourceAttribs& Attribs) const
     {
-        return BindPoint         == Attribs.BindPoint          &&
-               BindCount         == Attribs.BindCount          &&
-               InputType         == Attribs.InputType          &&
-               SRVDimension      == Attribs.SRVDimension       &&
-               SamplerOrTexSRVId == Attribs.SamplerOrTexSRVId;
+        return BindPoint == Attribs.BindPoint &&
+            BindCount == Attribs.BindCount &&
+            InputType == Attribs.InputType &&
+            SRVDimension == Attribs.SRVDimension &&
+            SamplerOrTexSRVId == Attribs.SamplerOrTexSRVId;
     }
 
-    size_t GetHash()const
+    size_t GetHash() const
     {
         return ComputeHash(BindPoint, BindCount, InputType, SRVDimension, SamplerOrTexSRVId);
     }
 
-    HLSLShaderResourceDesc GetHLSLResourceDesc()const;
+    HLSLShaderResourceDesc GetHLSLResourceDesc() const;
 
 private:
     friend class ShaderResources;
 
-    Uint32 GetCombinedSamplerId()const
+    Uint32 GetCombinedSamplerId() const
     {
-        VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Invalid input type: D3D_SIT_TEXTURE is expected" );
+        VERIFY(GetInputType() == D3D_SIT_TEXTURE && GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER, "Invalid input type: D3D_SIT_TEXTURE is expected");
         return SamplerOrTexSRVId;
     }
 
     void SetTexSRVId(Uint32 TexSRVId)
     {
-        VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected" );
+        VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected");
         VERIFY(TexSRVId < (1 << SamplerOrTexSRVIdBits), "TexSRVId (", TexSRVId, ") is out of representable range");
         SamplerOrTexSRVId = TexSRVId;
     }
 
-    Uint32 GetCombinedTexSRVId()const
+    Uint32 GetCombinedTexSRVId() const
     {
-        VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected" );
+        VERIFY(GetInputType() == D3D_SIT_SAMPLER, "Invalid input type: D3D_SIT_SAMPLER is expected");
         return SamplerOrTexSRVId;
     }
 };
-static_assert(sizeof(D3DShaderResourceAttribs) == sizeof(void*) + sizeof(Uint32)*2, "Unexpected sizeof(D3DShaderResourceAttribs)");
+static_assert(sizeof(D3DShaderResourceAttribs) == sizeof(void*) + sizeof(Uint32) * 2, "Unexpected sizeof(D3DShaderResourceAttribs)");
 
 
 /// Diligent::ShaderResources class
 class ShaderResources
 {
 public:
-    ShaderResources(SHADER_TYPE ShaderType)noexcept :
-        m_ShaderType(ShaderType)
+    ShaderResources(SHADER_TYPE ShaderType) noexcept :
+        m_ShaderType{ShaderType}
     {
     }
 
+    // clang-format off
     ShaderResources             (const ShaderResources&)  = delete;
     ShaderResources             (      ShaderResources&&) = delete;
     ShaderResources& operator = (const ShaderResources&)  = delete;
     ShaderResources& operator = (      ShaderResources&&) = delete;
-    
+    // clang-format on
+
     ~ShaderResources();
-    
+
+    // clang-format off
     Uint32 GetNumCBs()        const noexcept { return (m_TexSRVOffset   - 0);                }
     Uint32 GetNumTexSRV()     const noexcept { return (m_TexUAVOffset   - m_TexSRVOffset);   }
     Uint32 GetNumTexUAV()     const noexcept { return (m_BufSRVOffset   - m_TexUAVOffset);   }
@@ -269,67 +286,68 @@ public:
     const D3DShaderResourceAttribs& GetBufSRV (Uint32 n)const noexcept { return GetResAttribs(n, GetNumBufSRV(),   m_BufSRVOffset);   }
     const D3DShaderResourceAttribs& GetBufUAV (Uint32 n)const noexcept { return GetResAttribs(n, GetNumBufUAV(),   m_BufUAVOffset);   }
     const D3DShaderResourceAttribs& GetSampler(Uint32 n)const noexcept { return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); }
+    // clang-format on
 
-    const D3DShaderResourceAttribs& GetCombinedSampler(const D3DShaderResourceAttribs& TexSRV)const noexcept
+    const D3DShaderResourceAttribs& GetCombinedSampler(const D3DShaderResourceAttribs& TexSRV) const noexcept
     {
         VERIFY(TexSRV.IsCombinedWithSampler(), "This texture SRV is not combined with any sampler");
         return GetSampler(TexSRV.GetCombinedSamplerId());
     }
 
-    const D3DShaderResourceAttribs& GetCombinedTextureSRV(const D3DShaderResourceAttribs& Sampler)const noexcept
+    const D3DShaderResourceAttribs& GetCombinedTextureSRV(const D3DShaderResourceAttribs& Sampler) const noexcept
     {
         VERIFY(Sampler.IsCombinedWithTexSRV(), "This sampler is not combined with any texture SRV");
         return GetTexSRV(Sampler.GetCombinedTexSRVId());
     }
 
-    SHADER_TYPE GetShaderType()const noexcept{return m_ShaderType;}
-
-    HLSLShaderResourceDesc GetHLSLShaderResourceDesc(Uint32 Index)const;
-
-    template<typename THandleCB,
-             typename THandleSampler,
-             typename THandleTexSRV,
-             typename THandleTexUAV,
-             typename THandleBufSRV,
-             typename THandleBufUAV>
-    void ProcessResources(THandleCB           HandleCB,
-                          THandleSampler      HandleSampler,
-                          THandleTexSRV       HandleTexSRV,
-                          THandleTexUAV       HandleTexUAV,
-                          THandleBufSRV       HandleBufSRV,
-                          THandleBufUAV       HandleBufUAV)const
+    SHADER_TYPE GetShaderType() const noexcept { return m_ShaderType; }
+
+    HLSLShaderResourceDesc GetHLSLShaderResourceDesc(Uint32 Index) const;
+
+    template <typename THandleCB,
+              typename THandleSampler,
+              typename THandleTexSRV,
+              typename THandleTexUAV,
+              typename THandleBufSRV,
+              typename THandleBufUAV>
+    void ProcessResources(THandleCB      HandleCB,
+                          THandleSampler HandleSampler,
+                          THandleTexSRV  HandleTexSRV,
+                          THandleTexUAV  HandleTexUAV,
+                          THandleBufSRV  HandleBufSRV,
+                          THandleBufUAV  HandleBufUAV) const
     {
-        for (Uint32 n=0; n < GetNumCBs(); ++n)
+        for (Uint32 n = 0; n < GetNumCBs(); ++n)
         {
             const auto& CB = GetCB(n);
             HandleCB(CB, n);
         }
 
-        for (Uint32 n=0; n < GetNumSamplers(); ++n)
+        for (Uint32 n = 0; n < GetNumSamplers(); ++n)
         {
             const auto& Sampler = GetSampler(n);
             HandleSampler(Sampler, n);
         }
 
-        for (Uint32 n=0; n < GetNumTexSRV(); ++n)
+        for (Uint32 n = 0; n < GetNumTexSRV(); ++n)
         {
             const auto& TexSRV = GetTexSRV(n);
             HandleTexSRV(TexSRV, n);
         }
-    
-        for (Uint32 n=0; n < GetNumTexUAV(); ++n)
+
+        for (Uint32 n = 0; n < GetNumTexUAV(); ++n)
         {
             const auto& TexUAV = GetTexUAV(n);
             HandleTexUAV(TexUAV, n);
         }
 
-        for (Uint32 n=0; n < GetNumBufSRV(); ++n)
+        for (Uint32 n = 0; n < GetNumBufSRV(); ++n)
         {
             const auto& BufSRV = GetBufSRV(n);
             HandleBufSRV(BufSRV, n);
         }
 
-        for (Uint32 n=0; n < GetNumBufUAV(); ++n)
+        for (Uint32 n = 0; n < GetNumBufUAV(); ++n)
         {
             const auto& BufUAV = GetBufUAV(n);
             HandleBufUAV(BufUAV, n);
@@ -338,91 +356,93 @@ public:
 
     bool        IsCompatibleWith(const ShaderResources& Resources) const;
     bool        IsUsingCombinedTextureSamplers() const { return m_SamplerSuffix != nullptr; }
-    const char* GetCombinedSamplerSuffix()       const { return m_SamplerSuffix; }
-    const Char* GetShaderName()                  const { return m_ShaderName; }
+    const char* GetCombinedSamplerSuffix() const { return m_SamplerSuffix; }
+    const Char* GetShaderName() const { return m_ShaderName; }
 
-    size_t GetHash()const;
+    size_t GetHash() const;
 
     SHADER_RESOURCE_VARIABLE_TYPE FindVariableType(const D3DShaderResourceAttribs&   ResourceAttribs,
-                                                   const PipelineResourceLayoutDesc& ResourceLayout)const;
+                                                   const PipelineResourceLayoutDesc& ResourceLayout) const;
 
     Int32 FindStaticSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
                             const PipelineResourceLayoutDesc& ResourceLayoutDesc,
-                            bool                              LogStaticSamplerArrayError)const;
+                            bool                              LogStaticSamplerArrayError) const;
 
     D3DShaderResourceCounters CountResources(const PipelineResourceLayoutDesc&    ResourceLayout,
                                              const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
                                              Uint32                               NumAllowedTypes,
-                                             bool                                 CountStaticSamplers)const noexcept;
+                                             bool                                 CountStaticSamplers) const noexcept;
 #ifdef DEVELOPMENT
     static void DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& ResourceLayout,
                                         const ShaderResources* const      pShaderResources[],
                                         Uint32                            NumShaders);
 #endif
 
-    void GetShaderModel(Uint32& Major, Uint32& Minor)const
+    void GetShaderModel(Uint32& Major, Uint32& Minor) const
     {
         Major = (m_ShaderVersion & 0x000000F0) >> 4;
         Minor = (m_ShaderVersion & 0x0000000F);
     }
 
 protected:
-    template<typename D3D_SHADER_DESC, 
-             typename D3D_SHADER_INPUT_BIND_DESC,
-             typename TShaderReflection,
-             typename TNewResourceHandler>
-    void Initialize(ID3DBlob*           pShaderByteCode, 
-                    TNewResourceHandler NewResHandler, 
+    template <typename D3D_SHADER_DESC,
+              typename D3D_SHADER_INPUT_BIND_DESC,
+              typename TShaderReflection,
+              typename TNewResourceHandler>
+    void Initialize(ID3DBlob*           pShaderByteCode,
+                    TNewResourceHandler NewResHandler,
                     const Char*         ShaderName,
                     const Char*         SamplerSuffix);
 
 
-    __forceinline D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset)noexcept
+    __forceinline D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset) noexcept
     {
         VERIFY(n < NumResources, "Resource index (", n, ") is out of range. Resource array size: ", NumResources);
         VERIFY_EXPR(Offset + n < m_TotalResources);
         return reinterpret_cast<D3DShaderResourceAttribs*>(m_MemoryBuffer.get())[Offset + n];
     }
 
-    __forceinline const D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset)const noexcept
+    __forceinline const D3DShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset) const noexcept
     {
         VERIFY(n < NumResources, "Resource index (", n, ") is out of range. Resource array size: ", NumResources);
         VERIFY_EXPR(Offset + n < m_TotalResources);
         return reinterpret_cast<const D3DShaderResourceAttribs*>(m_MemoryBuffer.get())[Offset + n];
     }
 
-    D3DShaderResourceAttribs& GetCB     (Uint32 n)noexcept{ return GetResAttribs(n, GetNumCBs(),                   0);   }
-    D3DShaderResourceAttribs& GetTexSRV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumTexSRV(),   m_TexSRVOffset);   }
-    D3DShaderResourceAttribs& GetTexUAV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumTexUAV(),   m_TexUAVOffset);   }
-    D3DShaderResourceAttribs& GetBufSRV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumBufSRV(),   m_BufSRVOffset);   }
-    D3DShaderResourceAttribs& GetBufUAV (Uint32 n)noexcept{ return GetResAttribs(n, GetNumBufUAV(),   m_BufUAVOffset);   }
-    D3DShaderResourceAttribs& GetSampler(Uint32 n)noexcept{ return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); }
+    // clang-format off
+    D3DShaderResourceAttribs& GetCB(Uint32 n)      noexcept { return GetResAttribs(n, GetNumCBs(), 0); }
+    D3DShaderResourceAttribs& GetTexSRV(Uint32 n)  noexcept { return GetResAttribs(n, GetNumTexSRV(), m_TexSRVOffset); }
+    D3DShaderResourceAttribs& GetTexUAV(Uint32 n)  noexcept { return GetResAttribs(n, GetNumTexUAV(), m_TexUAVOffset); }
+    D3DShaderResourceAttribs& GetBufSRV(Uint32 n)  noexcept { return GetResAttribs(n, GetNumBufSRV(), m_BufSRVOffset); }
+    D3DShaderResourceAttribs& GetBufUAV(Uint32 n)  noexcept { return GetResAttribs(n, GetNumBufUAV(), m_BufUAVOffset); }
+    D3DShaderResourceAttribs& GetSampler(Uint32 n) noexcept { return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); }
+    // clang-format on
 
 private:
-    void AllocateMemory(IMemoryAllocator&                Allocator, 
+    void AllocateMemory(IMemoryAllocator&                Allocator,
                         const D3DShaderResourceCounters& ResCounters,
                         size_t                           ResourceNamesPoolSize);
 
-    Uint32 FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix)const;
+    Uint32 FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix) const;
 
     // Memory buffer that holds all resources as continuous chunk of memory:
     // | CBs | TexSRVs | TexUAVs | BufSRVs | BufUAVs | Samplers |  Resource Names  |
     //
 
-    std::unique_ptr< void, STDDeleterRawMem<void> > m_MemoryBuffer;
+    std::unique_ptr<void, STDDeleterRawMem<void>> m_MemoryBuffer;
 
     StringPool  m_ResourceNames;
-    const char* m_SamplerSuffix = nullptr; // The suffix and the shader name 
+    const char* m_SamplerSuffix = nullptr; // The suffix and the shader name
     const char* m_ShaderName    = nullptr; // are put into the m_ResourceNames
 
     // Offsets in elements of D3DShaderResourceAttribs
     typedef Uint16 OffsetType;
-    OffsetType m_TexSRVOffset   = 0;
-    OffsetType m_TexUAVOffset   = 0;
-    OffsetType m_BufSRVOffset   = 0;
-    OffsetType m_BufUAVOffset   = 0;
-    OffsetType m_SamplersOffset = 0;
-    OffsetType m_TotalResources = 0;
+    OffsetType     m_TexSRVOffset   = 0;
+    OffsetType     m_TexUAVOffset   = 0;
+    OffsetType     m_BufSRVOffset   = 0;
+    OffsetType     m_BufUAVOffset   = 0;
+    OffsetType     m_SamplersOffset = 0;
+    OffsetType     m_TotalResources = 0;
 
     const SHADER_TYPE m_ShaderType;
 
@@ -430,11 +450,11 @@ private:
 };
 
 
-template<typename D3D_SHADER_DESC, 
-         typename D3D_SHADER_INPUT_BIND_DESC,
-         typename TShaderReflection, 
-         typename TNewResourceHandler>
-void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode, 
+template <typename D3D_SHADER_DESC,
+          typename D3D_SHADER_INPUT_BIND_DESC,
+          typename TShaderReflection,
+          typename TNewResourceHandler>
+void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
                                  TNewResourceHandler NewResHandler,
                                  const Char*         ShaderName,
                                  const Char*         CombinedSamplerSuffix)
@@ -443,63 +463,63 @@ void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
     LoadD3DShaderResources<D3D_SHADER_DESC, D3D_SHADER_INPUT_BIND_DESC, TShaderReflection>(
         pShaderByteCode,
 
-        [&](const D3D_SHADER_DESC& d3dShaderDesc)
+        [&](const D3D_SHADER_DESC& d3dShaderDesc) //
         {
             m_ShaderVersion = d3dShaderDesc.Version;
         },
 
-        [&](const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize)
+        [&](const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize) //
         {
             VERIFY_EXPR(ShaderName != nullptr);
-            ResourceNamesPoolSize += strlen(ShaderName)+1;
+            ResourceNamesPoolSize += strlen(ShaderName) + 1;
 
             if (CombinedSamplerSuffix != nullptr)
-                ResourceNamesPoolSize += strlen(CombinedSamplerSuffix)+1;
+                ResourceNamesPoolSize += strlen(CombinedSamplerSuffix) + 1;
 
             AllocateMemory(GetRawAllocator(), ResCounters, ResourceNamesPoolSize);
         },
 
-        [&](const D3DShaderResourceAttribs& CBAttribs)
+        [&](const D3DShaderResourceAttribs& CBAttribs) //
         {
             VERIFY_EXPR(CBAttribs.GetInputType() == D3D_SIT_CBUFFER);
             auto* pNewCB = new (&GetCB(CurrCB++)) D3DShaderResourceAttribs(m_ResourceNames, CBAttribs);
             NewResHandler.OnNewCB(*pNewCB);
         },
 
-        [&](const D3DShaderResourceAttribs& TexUAV)
+        [&](const D3DShaderResourceAttribs& TexUAV) //
         {
             VERIFY_EXPR(TexUAV.GetInputType() == D3D_SIT_UAV_RWTYPED && TexUAV.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER);
             auto* pNewTexUAV = new (&GetTexUAV(CurrTexUAV++)) D3DShaderResourceAttribs(m_ResourceNames, TexUAV);
             NewResHandler.OnNewTexUAV(*pNewTexUAV);
         },
 
-        [&](const D3DShaderResourceAttribs& BuffUAV)
+        [&](const D3DShaderResourceAttribs& BuffUAV) //
         {
             VERIFY_EXPR(BuffUAV.GetInputType() == D3D_SIT_UAV_RWTYPED && BuffUAV.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER || BuffUAV.GetInputType() == D3D_SIT_UAV_RWSTRUCTURED || BuffUAV.GetInputType() == D3D_SIT_UAV_RWBYTEADDRESS);
             auto* pNewBufUAV = new (&GetBufUAV(CurrBufUAV++)) D3DShaderResourceAttribs(m_ResourceNames, BuffUAV);
             NewResHandler.OnNewBuffUAV(*pNewBufUAV);
         },
 
-        [&](const D3DShaderResourceAttribs& BuffSRV)
+        [&](const D3DShaderResourceAttribs& BuffSRV) //
         {
             VERIFY_EXPR(BuffSRV.GetInputType() == D3D_SIT_TEXTURE && BuffSRV.GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER || BuffSRV.GetInputType() == D3D_SIT_STRUCTURED || BuffSRV.GetInputType() == D3D_SIT_BYTEADDRESS);
             auto* pNewBuffSRV = new (&GetBufSRV(CurrBufSRV++)) D3DShaderResourceAttribs(m_ResourceNames, BuffSRV);
             NewResHandler.OnNewBuffSRV(*pNewBuffSRV);
         },
 
-        [&](const D3DShaderResourceAttribs& SamplerAttribs)
+        [&](const D3DShaderResourceAttribs& SamplerAttribs) //
         {
             VERIFY_EXPR(SamplerAttribs.GetInputType() == D3D_SIT_SAMPLER);
             auto* pNewSampler = new (&GetSampler(CurrSampler++)) D3DShaderResourceAttribs(m_ResourceNames, SamplerAttribs);
             NewResHandler.OnNewSampler(*pNewSampler);
         },
 
-        [&](const D3DShaderResourceAttribs& TexAttribs)
+        [&](const D3DShaderResourceAttribs& TexAttribs) //
         {
             VERIFY_EXPR(TexAttribs.GetInputType() == D3D_SIT_TEXTURE && TexAttribs.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER);
-            VERIFY(CurrSampler == GetNumSamplers(), "All samplers must be initialized before texture SRVs" );
+            VERIFY(CurrSampler == GetNumSamplers(), "All samplers must be initialized before texture SRVs");
 
-            auto SamplerId = CombinedSamplerSuffix != nullptr ? FindAssignedSamplerId(TexAttribs, CombinedSamplerSuffix) : D3DShaderResourceAttribs::InvalidSamplerId;
+            auto  SamplerId  = CombinedSamplerSuffix != nullptr ? FindAssignedSamplerId(TexAttribs, CombinedSamplerSuffix) : D3DShaderResourceAttribs::InvalidSamplerId;
             auto* pNewTexSRV = new (&GetTexSRV(CurrTexSRV)) D3DShaderResourceAttribs(m_ResourceNames, TexAttribs, SamplerId);
             if (SamplerId != D3DShaderResourceAttribs::InvalidSamplerId)
             {
@@ -507,7 +527,8 @@ void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
             }
             ++CurrTexSRV;
             NewResHandler.OnNewTexSRV(*pNewTexSRV);
-        });
+        } //
+    );
 
     m_ShaderName = m_ResourceNames.CopyString(ShaderName);
 
@@ -516,7 +537,7 @@ void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
         m_SamplerSuffix = m_ResourceNames.CopyString(CombinedSamplerSuffix);
 
 #ifdef DEVELOPMENT
-        for (Uint32 n=0; n < GetNumSamplers(); ++n)
+        for (Uint32 n = 0; n < GetNumSamplers(); ++n)
         {
             const auto& Sampler = GetSampler(n);
             if (!Sampler.IsCombinedWithTexSRV())
@@ -526,33 +547,37 @@ void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
     }
 
     VERIFY_EXPR(m_ResourceNames.GetRemainingSize() == 0);
+    // clang-format off
     VERIFY(CurrCB      == GetNumCBs(),      "Not all CBs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called");
     VERIFY(CurrTexSRV  == GetNumTexSRV(),   "Not all Tex SRVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" );
     VERIFY(CurrTexUAV  == GetNumTexUAV(),   "Not all Tex UAVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" );
     VERIFY(CurrBufSRV  == GetNumBufSRV(),   "Not all Buf SRVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" );
     VERIFY(CurrBufUAV  == GetNumBufUAV(),   "Not all Buf UAVs are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" );
     VERIFY(CurrSampler == GetNumSamplers(), "Not all Samplers are initialized which will cause a crash when ~D3DShaderResourceAttribs() is called" );
+    // clang-format on
 }
 
-}
+} // namespace Diligent
 
 namespace std
 {
-    template<>
-    struct hash<Diligent::D3DShaderResourceAttribs>
+
+template <>
+struct hash<Diligent::D3DShaderResourceAttribs>
+{
+    size_t operator()(const Diligent::D3DShaderResourceAttribs& Attribs) const
     {
-        size_t operator()(const Diligent::D3DShaderResourceAttribs &Attribs) const
-        {
-            return Attribs.GetHash();
-        }
-    };
+        return Attribs.GetHash();
+    }
+};
 
-    template<>
-    struct hash<Diligent::ShaderResources>
+template <>
+struct hash<Diligent::ShaderResources>
+{
+    size_t operator()(const Diligent::ShaderResources& Res) const
     {
-        size_t operator()(const Diligent::ShaderResources &Res) const
-        {
-            return Res.GetHash();
-        }
-    };
-}
+        return Res.GetHash();
+    }
+};
+
+} // namespace std
diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h
index a8716edb..f69d66e4 100644
--- a/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h
+++ b/Graphics/GraphicsEngineD3DBase/include/ShaderVariableD3DBase.h
@@ -31,51 +31,55 @@
 
 namespace Diligent
 {
-    struct D3DVariableIDComparator
+
+struct D3DVariableIDComparator
+{
+    bool operator()(const INTERFACE_ID& IID) const
     {
-        bool operator() (const INTERFACE_ID& IID)const
-        {
-            return IID == IID_ShaderResourceVariableD3D || IID == IID_ShaderResourceVariable || IID == IID_Unknown;
-        }
-    };
+        return IID == IID_ShaderResourceVariableD3D || IID == IID_ShaderResourceVariable || IID == IID_Unknown;
+    }
+};
+
+template <typename TShaderResourceLayout>
+struct ShaderVariableD3DBase : public ShaderVariableBase<TShaderResourceLayout, IShaderResourceVariableD3D, D3DVariableIDComparator>
+{
+    using TBase = ShaderVariableBase<TShaderResourceLayout, IShaderResourceVariableD3D, D3DVariableIDComparator>;
 
-    template<typename TShaderResourceLayout>
-    struct ShaderVariableD3DBase : public ShaderVariableBase<TShaderResourceLayout, IShaderResourceVariableD3D, D3DVariableIDComparator>
+    ShaderVariableD3DBase(TShaderResourceLayout&          ParentResLayout,
+                          const D3DShaderResourceAttribs& Attribs,
+                          SHADER_RESOURCE_VARIABLE_TYPE   VariableType) :
+        // clang-format off
+        TBase          {ParentResLayout},
+        m_Attribs      {Attribs        },
+        m_VariableType {VariableType   }
+    // clang-format on
     {
-        using TBase = ShaderVariableBase<TShaderResourceLayout, IShaderResourceVariableD3D, D3DVariableIDComparator>;
+    }
 
-        ShaderVariableD3DBase(TShaderResourceLayout&            ParentResLayout,
-                              const D3DShaderResourceAttribs&   Attribs,
-                              SHADER_RESOURCE_VARIABLE_TYPE     VariableType) : 
-            TBase          {ParentResLayout},
-            m_Attribs      {Attribs        },
-            m_VariableType {VariableType   }
-        {
-        }
+    virtual SHADER_RESOURCE_VARIABLE_TYPE GetType() const override final
+    {
+        return m_VariableType;
+    }
 
-        virtual SHADER_RESOURCE_VARIABLE_TYPE GetType()const override final
-        {
-            return m_VariableType;
-        }
+    virtual ShaderResourceDesc GetResourceDesc() const override final
+    {
+        return GetHLSLResourceDesc();
+    }
 
-        virtual ShaderResourceDesc GetResourceDesc()const override final
-        {
-            return GetHLSLResourceDesc();
-        }
+    virtual HLSLShaderResourceDesc GetHLSLResourceDesc() const override final
+    {
+        return m_Attribs.GetHLSLResourceDesc();
+    }
 
-        virtual HLSLShaderResourceDesc GetHLSLResourceDesc()const override final
-        {
-            return m_Attribs.GetHLSLResourceDesc();
-        }
+    virtual Uint32 GetIndex() const override final
+    {
+        return m_ParentResLayout.GetVariableIndex(*this);
+    }
 
-        virtual Uint32 GetIndex()const override final
-        {
-            return m_ParentResLayout.GetVariableIndex(*this);
-        }
+    const D3DShaderResourceAttribs& m_Attribs;
 
-        const D3DShaderResourceAttribs&     m_Attribs;
+protected:
+    const SHADER_RESOURCE_VARIABLE_TYPE m_VariableType;
+};
 
-    protected:
-        const SHADER_RESOURCE_VARIABLE_TYPE m_VariableType;
-    };
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h b/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h
index 6ad6e0a9..58b97309 100644
--- a/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h
+++ b/Graphics/GraphicsEngineD3DBase/include/SwapChainD3DBase.h
@@ -31,208 +31,212 @@
 
 namespace Diligent
 {
-    /// Base implementation of a D3D swap chain
-    template<class BaseInterface, typename DXGISwapChainType>
-    class SwapChainD3DBase : public SwapChainBase<BaseInterface>
+
+/// Base implementation of a D3D swap chain
+template<class BaseInterface, typename DXGISwapChainType>
+class SwapChainD3DBase : public SwapChainBase<BaseInterface>
+{
+public:
+    using TBase = SwapChainBase<BaseInterface>;
+    SwapChainD3DBase(IReferenceCounters*        pRefCounters,
+                        IRenderDevice*             pDevice,
+                        IDeviceContext*            pDeviceContext,
+                        const SwapChainDesc&       SCDesc,
+                        const FullScreenModeDesc&  FSDesc,
+                        void*                      pNativeWndHandle) :
+        // clang-format off
+        TBase{pRefCounters, pDevice, pDeviceContext, SCDesc},
+        m_FSDesc           {FSDesc},
+        m_pNativeWndHandle {pNativeWndHandle}
+        // clang-format on
+    {}
+
+    ~SwapChainD3DBase()
     {
-    public:
-        using TBase = SwapChainBase<BaseInterface>;
-        SwapChainD3DBase(IReferenceCounters*        pRefCounters,
-                         IRenderDevice*             pDevice,
-                         IDeviceContext*            pDeviceContext,
-                         const SwapChainDesc&       SCDesc,
-                         const FullScreenModeDesc&  FSDesc,
-                         void*                      pNativeWndHandle) :
-            TBase{pRefCounters, pDevice, pDeviceContext, SCDesc},
-            m_FSDesc           {FSDesc},
-            m_pNativeWndHandle {pNativeWndHandle}
-        {}
-
-        ~SwapChainD3DBase()
+        if (m_pSwapChain)
         {
-            if (m_pSwapChain)
-            {
-                // Swap chain must be in windowed mode when it is destroyed
-                // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying
-                BOOL IsFullScreen = FALSE;
-                m_pSwapChain->GetFullscreenState(&IsFullScreen, nullptr);
-                if (IsFullScreen)
-                    m_pSwapChain->SetFullscreenState(FALSE, nullptr);
-            }
+            // Swap chain must be in windowed mode when it is destroyed
+            // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying
+            BOOL IsFullScreen = FALSE;
+            m_pSwapChain->GetFullscreenState(&IsFullScreen, nullptr);
+            if (IsFullScreen)
+                m_pSwapChain->SetFullscreenState(FALSE, nullptr);
         }
+    }
 
-    protected:
-        virtual void UpdateSwapChain(bool CreateNew) = 0;
+protected:
+    virtual void UpdateSwapChain(bool CreateNew) = 0;
 
-        void CreateDXGISwapChain(IUnknown *pD3D11DeviceOrD3D12CmdQueue)
-        {
+    void CreateDXGISwapChain(IUnknown *pD3D11DeviceOrD3D12CmdQueue)
+    {
 #if PLATFORM_WIN32
-            auto hWnd = reinterpret_cast<HWND>(m_pNativeWndHandle);
-            if (m_SwapChainDesc.Width == 0 || m_SwapChainDesc.Height == 0)
+        auto hWnd = reinterpret_cast<HWND>(m_pNativeWndHandle);
+        if (m_SwapChainDesc.Width == 0 || m_SwapChainDesc.Height == 0)
+        {
+            RECT rc;
+            if (m_FSDesc.Fullscreen)
+            {
+                const HWND hDesktop = GetDesktopWindow();
+                GetWindowRect(hDesktop, &rc);
+            }
+            else
             {
-                RECT rc;
-                if (m_FSDesc.Fullscreen)
-                {
-                    const HWND hDesktop = GetDesktopWindow();
-                    GetWindowRect(hDesktop, &rc);
-                }
-                else
-                {
-                    GetClientRect(hWnd, &rc);
-                }
-                m_SwapChainDesc.Width = rc.right - rc.left;
-                m_SwapChainDesc.Height = rc.bottom - rc.top;
+                GetClientRect(hWnd, &rc);
             }
+            m_SwapChainDesc.Width = rc.right - rc.left;
+            m_SwapChainDesc.Height = rc.bottom - rc.top;
+        }
 #endif
 
-            auto DXGIColorBuffFmt = TexFormatToDXGI_Format(m_SwapChainDesc.ColorBufferFormat);
-
-            DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
-            swapChainDesc.Width  = m_SwapChainDesc.Width;
-            swapChainDesc.Height = m_SwapChainDesc.Height;
-            //  Flip model swapchains (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD) only support the following Formats: 
-            //  - DXGI_FORMAT_R16G16B16A16_FLOAT 
-            //  - DXGI_FORMAT_B8G8R8A8_UNORM
-            //  - DXGI_FORMAT_R8G8B8A8_UNORM
-            //  - DXGI_FORMAT_R10G10B10A2_UNORM
-            // If RGBA8_UNORM_SRGB swap chain is required, we will create RGBA8_UNORM swap chain, but
-            // create RGBA8_UNORM_SRGB render target view
-            switch (DXGIColorBuffFmt)
-            {
-                case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-                    swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
-                    break;
+        auto DXGIColorBuffFmt = TexFormatToDXGI_Format(m_SwapChainDesc.ColorBufferFormat);
+
+        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
+        swapChainDesc.Width  = m_SwapChainDesc.Width;
+        swapChainDesc.Height = m_SwapChainDesc.Height;
+        //  Flip model swapchains (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD) only support the following Formats: 
+        //  - DXGI_FORMAT_R16G16B16A16_FLOAT 
+        //  - DXGI_FORMAT_B8G8R8A8_UNORM
+        //  - DXGI_FORMAT_R8G8B8A8_UNORM
+        //  - DXGI_FORMAT_R10G10B10A2_UNORM
+        // If RGBA8_UNORM_SRGB swap chain is required, we will create RGBA8_UNORM swap chain, but
+        // create RGBA8_UNORM_SRGB render target view
+        switch (DXGIColorBuffFmt)
+        {
+            case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+                break;
 
-                case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-                    swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-                    break;
+            case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+                swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+                break;
 
-                default:
-                    swapChainDesc.Format = DXGIColorBuffFmt;
-            }
+            default:
+                swapChainDesc.Format = DXGIColorBuffFmt;
+        }
 
-            swapChainDesc.Stereo             = FALSE;
+        swapChainDesc.Stereo             = FALSE;
 
-            // Multi-sampled swap chains are not supported anymore. CreateSwapChainForHwnd() fails when sample count is not 1
-            // for any swap effect.
-            swapChainDesc.SampleDesc.Count   = 1;
-            swapChainDesc.SampleDesc.Quality = 0;
+        // Multi-sampled swap chains are not supported anymore. CreateSwapChainForHwnd() fails when sample count is not 1
+        // for any swap effect.
+        swapChainDesc.SampleDesc.Count   = 1;
+        swapChainDesc.SampleDesc.Quality = 0;
             
-            DEV_CHECK_ERR(m_SwapChainDesc.Usage != 0, "No swap chain usage flags defined");
-            swapChainDesc.BufferUsage = 0;
-            if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_RENDER_TARGET)
-                swapChainDesc.BufferUsage |= DXGI_USAGE_RENDER_TARGET_OUTPUT;
-            if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_SHADER_INPUT)
-                swapChainDesc.BufferUsage |= DXGI_USAGE_SHADER_INPUT;
-            //if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_COPY_SOURCE)
-            //    ;
-
-            swapChainDesc.BufferCount        = m_SwapChainDesc.BufferCount;
-            swapChainDesc.Scaling            = DXGI_SCALING_NONE;
+        DEV_CHECK_ERR(m_SwapChainDesc.Usage != 0, "No swap chain usage flags defined");
+        swapChainDesc.BufferUsage = 0;
+        if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_RENDER_TARGET)
+            swapChainDesc.BufferUsage |= DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_SHADER_INPUT)
+            swapChainDesc.BufferUsage |= DXGI_USAGE_SHADER_INPUT;
+        //if (m_SwapChainDesc.Usage & SWAP_CHAIN_USAGE_COPY_SOURCE)
+        //    ;
+
+        swapChainDesc.BufferCount        = m_SwapChainDesc.BufferCount;
+        swapChainDesc.Scaling            = DXGI_SCALING_NONE;
 
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-            // DXGI_SCALING_NONE is supported starting with Windows 8
-            if (!IsWindows8OrGreater())
-                swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+        // DXGI_SCALING_NONE is supported starting with Windows 8
+        if (!IsWindows8OrGreater())
+            swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
 #endif
 
-            // DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is the flip presentation model, where the contents of the back 
-            // buffer is preserved after the call to Present. This flag cannot be used with multisampling.
-            // The only swap effect that supports multisampling is DXGI_SWAP_EFFECT_DISCARD.
-            // Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD.
-            swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+        // DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is the flip presentation model, where the contents of the back 
+        // buffer is preserved after the call to Present. This flag cannot be used with multisampling.
+        // The only swap effect that supports multisampling is DXGI_SWAP_EFFECT_DISCARD.
+        // Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD.
+        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
 
-            swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; //  Transparency behavior is not specified
+        swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; //  Transparency behavior is not specified
 
-            // DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH enables an application to switch modes by calling 
-            // IDXGISwapChain::ResizeTarget(). When switching from windowed to fullscreen mode, the display 
-            // mode (or monitor resolution) will be changed to match the dimensions of the application window.
-            swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+        // DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH enables an application to switch modes by calling 
+        // IDXGISwapChain::ResizeTarget(). When switching from windowed to fullscreen mode, the display 
+        // mode (or monitor resolution) will be changed to match the dimensions of the application window.
+        swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
 
-            CComPtr<IDXGISwapChain1> pSwapChain1;
-            CComPtr<IDXGIFactory2> factory;
-            HRESULT hr = CreateDXGIFactory1(__uuidof(factory), reinterpret_cast<void**>(static_cast<IDXGIFactory2**>(&factory)));
-            CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI factory");
+        CComPtr<IDXGISwapChain1> pSwapChain1;
+        CComPtr<IDXGIFactory2> factory;
+        HRESULT hr = CreateDXGIFactory1(__uuidof(factory), reinterpret_cast<void**>(static_cast<IDXGIFactory2**>(&factory)));
+        CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI factory");
 
 #if PLATFORM_WIN32
 
-            DXGI_SWAP_CHAIN_FULLSCREEN_DESC FullScreenDesc = {};
-            FullScreenDesc.Windowed = m_FSDesc.Fullscreen ? FALSE : TRUE;
-            FullScreenDesc.RefreshRate.Numerator   = m_FSDesc.RefreshRateNumerator;
-            FullScreenDesc.RefreshRate.Denominator = m_FSDesc.RefreshRateDenominator;
-            FullScreenDesc.Scaling          = static_cast<DXGI_MODE_SCALING>(m_FSDesc.Scaling);
-            FullScreenDesc.ScanlineOrdering = static_cast<DXGI_MODE_SCANLINE_ORDER>(m_FSDesc.ScanlineOrder);
-            hr = factory->CreateSwapChainForHwnd(pD3D11DeviceOrD3D12CmdQueue, hWnd, &swapChainDesc, &FullScreenDesc, nullptr, &pSwapChain1);
-            CHECK_D3D_RESULT_THROW(hr, "Failed to create Swap Chain");
+        DXGI_SWAP_CHAIN_FULLSCREEN_DESC FullScreenDesc = {};
+        FullScreenDesc.Windowed = m_FSDesc.Fullscreen ? FALSE : TRUE;
+        FullScreenDesc.RefreshRate.Numerator   = m_FSDesc.RefreshRateNumerator;
+        FullScreenDesc.RefreshRate.Denominator = m_FSDesc.RefreshRateDenominator;
+        FullScreenDesc.Scaling          = static_cast<DXGI_MODE_SCALING>(m_FSDesc.Scaling);
+        FullScreenDesc.ScanlineOrdering = static_cast<DXGI_MODE_SCANLINE_ORDER>(m_FSDesc.ScanlineOrder);
+        hr = factory->CreateSwapChainForHwnd(pD3D11DeviceOrD3D12CmdQueue, hWnd, &swapChainDesc, &FullScreenDesc, nullptr, &pSwapChain1);
+        CHECK_D3D_RESULT_THROW(hr, "Failed to create Swap Chain");
             
+        {
+            // This is silly, but IDXGIFactory used for MakeWindowAssociation must be retrieved via 
+            // calling IDXGISwapchain::GetParent first, otherwise it won't work
+            // https://www.gamedev.net/forums/topic/634235-dxgidisabling-altenter/?do=findComment&comment=4999990
+            CComPtr<IDXGIFactory1> pFactoryFromSC;
+            if (SUCCEEDED(pSwapChain1->GetParent(__uuidof(pFactoryFromSC), (void **)&pFactoryFromSC)))
             {
-                // This is silly, but IDXGIFactory used for MakeWindowAssociation must be retrieved via 
-                // calling IDXGISwapchain::GetParent first, otherwise it won't work
-                // https://www.gamedev.net/forums/topic/634235-dxgidisabling-altenter/?do=findComment&comment=4999990
-                CComPtr<IDXGIFactory1> pFactoryFromSC;
-                if (SUCCEEDED(pSwapChain1->GetParent(__uuidof(pFactoryFromSC), (void **)&pFactoryFromSC)))
-                {
-                    // Do not allow the swap chain to handle Alt+Enter
-                    pFactoryFromSC->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
-                }
+                // Do not allow the swap chain to handle Alt+Enter
+                pFactoryFromSC->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
             }
+        }
             
 #elif PLATFORM_UNIVERSAL_WINDOWS
 
-            if (m_FSDesc.Fullscreen)
-                LOG_WARNING_MESSAGE("UWP applications do not support fullscreen mode");
+        if (m_FSDesc.Fullscreen)
+            LOG_WARNING_MESSAGE("UWP applications do not support fullscreen mode");
 
-            hr = factory->CreateSwapChainForCoreWindow(
-                pD3D11DeviceOrD3D12CmdQueue,
-                reinterpret_cast<IUnknown*>(m_pNativeWndHandle),
-                &swapChainDesc,
-                nullptr,
-                &pSwapChain1);
-            CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI swap chain");
+        hr = factory->CreateSwapChainForCoreWindow(
+            pD3D11DeviceOrD3D12CmdQueue,
+            reinterpret_cast<IUnknown*>(m_pNativeWndHandle),
+            &swapChainDesc,
+            nullptr,
+            &pSwapChain1);
+        CHECK_D3D_RESULT_THROW(hr, "Failed to create DXGI swap chain");
 
-            // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and
-            // ensures that the application will only render after each VSync, minimizing power consumption.
-            //pDXGIDevice->SetMaximumFrameLatency( 1 );
+        // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and
+        // ensures that the application will only render after each VSync, minimizing power consumption.
+        //pDXGIDevice->SetMaximumFrameLatency( 1 );
 
 #endif
 
-            pSwapChain1->QueryInterface(__uuidof(m_pSwapChain), reinterpret_cast<void**>(static_cast<DXGISwapChainType**>(&m_pSwapChain)));
+        pSwapChain1->QueryInterface(__uuidof(m_pSwapChain), reinterpret_cast<void**>(static_cast<DXGISwapChainType**>(&m_pSwapChain)));
 
-        }
+    }
 
-        virtual void SetFullscreenMode(const DisplayModeAttribs &DisplayMode)override final
+    virtual void SetFullscreenMode(const DisplayModeAttribs &DisplayMode)override final
+    {
+        if (m_pSwapChain)
         {
-            if (m_pSwapChain)
-            {
-                // If we are already in fullscreen mode, we need to switch to windowed mode first,
-                // because a swap chain must be in windowed mode when it is released.
-                // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying
-                if (m_FSDesc.Fullscreen)
-                    m_pSwapChain->SetFullscreenState(FALSE, nullptr);
-                m_FSDesc.Fullscreen             = True;
-                m_FSDesc.RefreshRateNumerator   = DisplayMode.RefreshRateNumerator;
-                m_FSDesc.RefreshRateDenominator = DisplayMode.RefreshRateDenominator;
-                m_FSDesc.Scaling                = DisplayMode.Scaling;
-                m_FSDesc.ScanlineOrder          = DisplayMode.ScanlineOrder;
-                m_SwapChainDesc.Width           = DisplayMode.Width;
-                m_SwapChainDesc.Height          = DisplayMode.Height;
-                if (DisplayMode.Format != TEX_FORMAT_UNKNOWN)
-                    m_SwapChainDesc.ColorBufferFormat = DisplayMode.Format;
-                UpdateSwapChain(true);
-            }
+            // If we are already in fullscreen mode, we need to switch to windowed mode first,
+            // because a swap chain must be in windowed mode when it is released.
+            // https://msdn.microsoft.com/en-us/library/windows/desktop/bb205075(v=vs.85).aspx#Destroying
+            if (m_FSDesc.Fullscreen)
+                m_pSwapChain->SetFullscreenState(FALSE, nullptr);
+            m_FSDesc.Fullscreen             = True;
+            m_FSDesc.RefreshRateNumerator   = DisplayMode.RefreshRateNumerator;
+            m_FSDesc.RefreshRateDenominator = DisplayMode.RefreshRateDenominator;
+            m_FSDesc.Scaling                = DisplayMode.Scaling;
+            m_FSDesc.ScanlineOrder          = DisplayMode.ScanlineOrder;
+            m_SwapChainDesc.Width           = DisplayMode.Width;
+            m_SwapChainDesc.Height          = DisplayMode.Height;
+            if (DisplayMode.Format != TEX_FORMAT_UNKNOWN)
+                m_SwapChainDesc.ColorBufferFormat = DisplayMode.Format;
+            UpdateSwapChain(true);
         }
+    }
 
-        virtual void SetWindowedMode()override final
+    virtual void SetWindowedMode()override final
+    {
+        if (m_FSDesc.Fullscreen)
         {
-            if (m_FSDesc.Fullscreen)
-            {
-                m_FSDesc.Fullscreen = False;
-                m_pSwapChain->SetFullscreenState(FALSE, nullptr);
-            }
+            m_FSDesc.Fullscreen = False;
+            m_pSwapChain->SetFullscreenState(FALSE, nullptr);
         }
+    }
+
+    FullScreenModeDesc m_FSDesc;
+    CComPtr<DXGISwapChainType> m_pSwapChain;
+    void* m_pNativeWndHandle;
+};
 
-        FullScreenModeDesc m_FSDesc;
-        CComPtr<DXGISwapChainType> m_pSwapChain;
-        void* m_pNativeWndHandle;
-    };
 }
diff --git a/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h b/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h
index 12ba8272..c52e195e 100644
--- a/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h
+++ b/Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h
@@ -33,7 +33,7 @@ namespace Diligent
 
 // {1EA0898C-1612-457F-B74E-808843D2CBE3}
 static constexpr INTERFACE_ID IID_ShaderD3D =
-{ 0x1ea0898c, 0x1612, 0x457f, { 0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3 } };
+    {0x1ea0898c, 0x1612, 0x457f, {0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3}};
 
 
 /// HLSL resource description
@@ -47,7 +47,7 @@ class IShaderD3D : public IShader
 {
 public:
     /// Returns HLSL shader resource description
-    virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index)const = 0;
+    virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index) const = 0;
 };
 
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp b/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp
index 1c366d90..037c87f3 100644
--- a/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp
+++ b/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp
@@ -30,237 +30,237 @@ namespace Diligent
 
 DXGI_FORMAT TypeToDXGI_Format(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized)
 {
-    switch(ValType)
+    switch (ValType)
     {
         case VT_FLOAT16:
         {
-            VERIFY( !bIsNormalized, "Floating point formats cannot be normalized" );
-            switch(NumComponents)
+            VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
+            switch (NumComponents)
             {
                 case 1: return DXGI_FORMAT_R16_FLOAT;
                 case 2: return DXGI_FORMAT_R16G16_FLOAT;
                 case 4: return DXGI_FORMAT_R16G16B16A16_FLOAT;
-                default: UNEXPECTED("Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
             }
         }
 
         case VT_FLOAT32:
         {
-            VERIFY( !bIsNormalized, "Floating point formats cannot be normalized" );
-            switch(NumComponents)
+            VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
+            switch (NumComponents)
             {
                 case 1: return DXGI_FORMAT_R32_FLOAT;
                 case 2: return DXGI_FORMAT_R32G32_FLOAT;
                 case 3: return DXGI_FORMAT_R32G32B32_FLOAT;
                 case 4: return DXGI_FORMAT_R32G32B32A32_FLOAT;
-                default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
             }
         }
 
         case VT_INT32:
         {
-            VERIFY( !bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead" );
-            switch(NumComponents)
+            VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
+            switch (NumComponents)
             {
                 case 1: return DXGI_FORMAT_R32_SINT;
                 case 2: return DXGI_FORMAT_R32G32_SINT;
                 case 3: return DXGI_FORMAT_R32G32B32_SINT;
                 case 4: return DXGI_FORMAT_R32G32B32A32_SINT;
-                default: UNEXPECTED("Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
             }
         }
 
         case VT_UINT32:
         {
-            VERIFY( !bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead" );
-            switch(NumComponents)
+            VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
+            switch (NumComponents)
             {
                 case 1: return DXGI_FORMAT_R32_UINT;
                 case 2: return DXGI_FORMAT_R32G32_UINT;
                 case 3: return DXGI_FORMAT_R32G32B32_UINT;
                 case 4: return DXGI_FORMAT_R32G32B32A32_UINT;
-                default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
             }
         }
 
         case VT_INT16:
         {
-            if( bIsNormalized )
+            if (bIsNormalized)
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R16_SNORM;
                     case 2: return DXGI_FORMAT_R16G16_SNORM;
                     case 4: return DXGI_FORMAT_R16G16B16A16_SNORM;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
             else
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R16_SINT;
                     case 2: return DXGI_FORMAT_R16G16_SINT;
                     case 4: return DXGI_FORMAT_R16G16B16A16_SINT;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
         }
 
         case VT_UINT16:
         {
-            if( bIsNormalized )
+            if (bIsNormalized)
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R16_UNORM;
                     case 2: return DXGI_FORMAT_R16G16_UNORM;
                     case 4: return DXGI_FORMAT_R16G16B16A16_UNORM;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
             else
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R16_UINT;
                     case 2: return DXGI_FORMAT_R16G16_UINT;
                     case 4: return DXGI_FORMAT_R16G16B16A16_UINT;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
         }
 
         case VT_INT8:
         {
-            if( bIsNormalized )
+            if (bIsNormalized)
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R8_SNORM;
                     case 2: return DXGI_FORMAT_R8G8_SNORM;
                     case 4: return DXGI_FORMAT_R8G8B8A8_SNORM;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
             else
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R8_SINT;
                     case 2: return DXGI_FORMAT_R8G8_SINT;
                     case 4: return DXGI_FORMAT_R8G8B8A8_SINT;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
         }
 
         case VT_UINT8:
         {
-            if( bIsNormalized )
+            if (bIsNormalized)
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R8_UNORM;
                     case 2: return DXGI_FORMAT_R8G8_UNORM;
                     case 4: return DXGI_FORMAT_R8G8B8A8_UNORM;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
             else
             {
-                switch(NumComponents)
+                switch (NumComponents)
                 {
                     case 1: return DXGI_FORMAT_R8_UINT;
                     case 2: return DXGI_FORMAT_R8G8_UINT;
                     case 4: return DXGI_FORMAT_R8G8B8A8_UINT;
-                    default: UNEXPECTED( "Unusupported number of components" ); return DXGI_FORMAT_UNKNOWN;
+                    default: UNEXPECTED("Unusupported number of components"); return DXGI_FORMAT_UNKNOWN;
                 }
             }
         }
 
-        default: UNEXPECTED( "Unusupported format" ); return DXGI_FORMAT_UNKNOWN;
+        default: UNEXPECTED("Unusupported format"); return DXGI_FORMAT_UNKNOWN;
     }
 }
 
-DXGI_FORMAT CorrectDXGIFormat( DXGI_FORMAT DXGIFormat, Uint32 BindFlags )
+DXGI_FORMAT CorrectDXGIFormat(DXGI_FORMAT DXGIFormat, Uint32 BindFlags)
 {
-    if( (BindFlags & BIND_DEPTH_STENCIL) && (BindFlags != BIND_DEPTH_STENCIL) )
+    if ((BindFlags & BIND_DEPTH_STENCIL) && (BindFlags != BIND_DEPTH_STENCIL))
     {
-        switch( DXGIFormat )
+        switch (DXGIFormat)
         {
             case DXGI_FORMAT_R32_TYPELESS:
             case DXGI_FORMAT_R32_FLOAT:
-            case DXGI_FORMAT_D32_FLOAT: 
-                DXGIFormat = DXGI_FORMAT_R32_TYPELESS; 
+            case DXGI_FORMAT_D32_FLOAT:
+                DXGIFormat = DXGI_FORMAT_R32_TYPELESS;
                 break;
 
             case DXGI_FORMAT_R24G8_TYPELESS:
-	        case DXGI_FORMAT_D24_UNORM_S8_UINT:
-	        case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-	        case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-		        DXGIFormat = DXGI_FORMAT_R24G8_TYPELESS;
+            case DXGI_FORMAT_D24_UNORM_S8_UINT:
+            case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+            case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+                DXGIFormat = DXGI_FORMAT_R24G8_TYPELESS;
                 break;
 
             case DXGI_FORMAT_R16_TYPELESS:
             case DXGI_FORMAT_R16_UNORM:
-            case DXGI_FORMAT_D16_UNORM: 
-                DXGIFormat = DXGI_FORMAT_R16_TYPELESS; 
+            case DXGI_FORMAT_D16_UNORM:
+                DXGIFormat = DXGI_FORMAT_R16_TYPELESS;
                 break;
 
             case DXGI_FORMAT_R32G8X24_TYPELESS:
             case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
             case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
             case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
-                DXGIFormat = DXGI_FORMAT_R32G8X24_TYPELESS; 
+                DXGIFormat = DXGI_FORMAT_R32G8X24_TYPELESS;
                 break;
 
-            default: 
-                UNEXPECTED( "Unsupported depth-stencil format" );
+            default:
+                UNEXPECTED("Unsupported depth-stencil format");
                 break;
         }
     }
 
-    if( BindFlags == BIND_DEPTH_STENCIL )
+    if (BindFlags == BIND_DEPTH_STENCIL)
     {
-        switch( DXGIFormat )
+        switch (DXGIFormat)
         {
             case DXGI_FORMAT_R32_TYPELESS:
             case DXGI_FORMAT_R32_FLOAT:
-                DXGIFormat = DXGI_FORMAT_D32_FLOAT; 
+                DXGIFormat = DXGI_FORMAT_D32_FLOAT;
                 break;
 
-	        case DXGI_FORMAT_R24G8_TYPELESS:
-	        case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-	        case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-		        DXGIFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
+            case DXGI_FORMAT_R24G8_TYPELESS:
+            case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+            case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+                DXGIFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
                 break;
 
             case DXGI_FORMAT_R16_TYPELESS:
             case DXGI_FORMAT_R16_UNORM:
-                DXGIFormat = DXGI_FORMAT_D16_UNORM; 
+                DXGIFormat = DXGI_FORMAT_D16_UNORM;
                 break;
         }
     }
 
-    if( BindFlags == BIND_SHADER_RESOURCE || BindFlags == BIND_UNORDERED_ACCESS )
+    if (BindFlags == BIND_SHADER_RESOURCE || BindFlags == BIND_UNORDERED_ACCESS)
     {
-        switch( DXGIFormat )
+        switch (DXGIFormat)
         {
             case DXGI_FORMAT_R32_TYPELESS:
             case DXGI_FORMAT_D32_FLOAT:
-                DXGIFormat = DXGI_FORMAT_R32_FLOAT; 
+                DXGIFormat = DXGI_FORMAT_R32_FLOAT;
                 break;
 
-	        case DXGI_FORMAT_R24G8_TYPELESS:
-	        case DXGI_FORMAT_D24_UNORM_S8_UINT:
-	        case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
-		        DXGIFormat = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
+            case DXGI_FORMAT_R24G8_TYPELESS:
+            case DXGI_FORMAT_D24_UNORM_S8_UINT:
+            case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+                DXGIFormat = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
                 break;
 
             case DXGI_FORMAT_R16_TYPELESS:
             case DXGI_FORMAT_D16_UNORM:
-                DXGIFormat = DXGI_FORMAT_R16_UNORM; 
+                DXGIFormat = DXGI_FORMAT_R16_UNORM;
                 break;
         }
     }
@@ -270,145 +270,147 @@ DXGI_FORMAT CorrectDXGIFormat( DXGI_FORMAT DXGIFormat, Uint32 BindFlags )
 
 DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags)
 {
-    static Bool bFormatMapIntialized = false;
+    static Bool        bFormatMapIntialized                    = false;
     static DXGI_FORMAT FmtToDXGIFmtMap[TEX_FORMAT_NUM_FORMATS] = {DXGI_FORMAT_UNKNOWN};
-    if( !bFormatMapIntialized )
+    if (!bFormatMapIntialized)
     {
-        FmtToDXGIFmtMap[ TEX_FORMAT_UNKNOWN ]                = DXGI_FORMAT_UNKNOWN;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_TYPELESS ]        = DXGI_FORMAT_R32G32B32A32_TYPELESS; 
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_FLOAT ]           = DXGI_FORMAT_R32G32B32A32_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_UINT ]            = DXGI_FORMAT_R32G32B32A32_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA32_SINT ]            = DXGI_FORMAT_R32G32B32A32_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_TYPELESS ]         = DXGI_FORMAT_R32G32B32_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_FLOAT ]            = DXGI_FORMAT_R32G32B32_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_UINT ]             = DXGI_FORMAT_R32G32B32_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB32_SINT ]             = DXGI_FORMAT_R32G32B32_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_TYPELESS ]        = DXGI_FORMAT_R16G16B16A16_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_FLOAT ]           = DXGI_FORMAT_R16G16B16A16_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_UNORM ]           = DXGI_FORMAT_R16G16B16A16_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_UINT ]            = DXGI_FORMAT_R16G16B16A16_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_SNORM ]           = DXGI_FORMAT_R16G16B16A16_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA16_SINT ]            = DXGI_FORMAT_R16G16B16A16_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG32_TYPELESS ]          = DXGI_FORMAT_R32G32_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG32_FLOAT ]             = DXGI_FORMAT_R32G32_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG32_UINT ]              = DXGI_FORMAT_R32G32_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG32_SINT ]              = DXGI_FORMAT_R32G32_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32G8X24_TYPELESS ]      = DXGI_FORMAT_R32G8X24_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_D32_FLOAT_S8X24_UINT ]   = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32_FLOAT_X8X24_TYPELESS ]= DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_X32_TYPELESS_G8X24_UINT ]= DXGI_FORMAT_X32_TYPELESS_G8X24_UINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_TYPELESS ]       = DXGI_FORMAT_R10G10B10A2_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_UNORM ]          = DXGI_FORMAT_R10G10B10A2_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB10A2_UINT ]           = DXGI_FORMAT_R10G10B10A2_UINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R11G11B10_FLOAT ]        = DXGI_FORMAT_R11G11B10_FLOAT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_TYPELESS ]         = DXGI_FORMAT_R8G8B8A8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UNORM ]            = DXGI_FORMAT_R8G8B8A8_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UNORM_SRGB ]       = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_UINT ]             = DXGI_FORMAT_R8G8B8A8_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_SNORM ]            = DXGI_FORMAT_R8G8B8A8_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGBA8_SINT ]             = DXGI_FORMAT_R8G8B8A8_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_TYPELESS ]          = DXGI_FORMAT_R16G16_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_FLOAT ]             = DXGI_FORMAT_R16G16_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_UNORM ]             = DXGI_FORMAT_R16G16_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_UINT ]              = DXGI_FORMAT_R16G16_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_SNORM ]             = DXGI_FORMAT_R16G16_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG16_SINT ]              = DXGI_FORMAT_R16G16_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32_TYPELESS ]           = DXGI_FORMAT_R32_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_D32_FLOAT ]              = DXGI_FORMAT_D32_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32_FLOAT ]              = DXGI_FORMAT_R32_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32_UINT ]               = DXGI_FORMAT_R32_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R32_SINT ]               = DXGI_FORMAT_R32_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R24G8_TYPELESS ]         = DXGI_FORMAT_R24G8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_D24_UNORM_S8_UINT ]      = DXGI_FORMAT_D24_UNORM_S8_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R24_UNORM_X8_TYPELESS ]  = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_X24_TYPELESS_G8_UINT ]   = DXGI_FORMAT_X24_TYPELESS_G8_UINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_TYPELESS ]           = DXGI_FORMAT_R8G8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_UNORM ]              = DXGI_FORMAT_R8G8_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_UINT ]               = DXGI_FORMAT_R8G8_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_SNORM ]              = DXGI_FORMAT_R8G8_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_SINT ]               = DXGI_FORMAT_R8G8_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_TYPELESS ]           = DXGI_FORMAT_R16_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_FLOAT ]              = DXGI_FORMAT_R16_FLOAT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_D16_UNORM ]              = DXGI_FORMAT_D16_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_UNORM ]              = DXGI_FORMAT_R16_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_UINT ]               = DXGI_FORMAT_R16_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_SNORM ]              = DXGI_FORMAT_R16_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R16_SINT ]               = DXGI_FORMAT_R16_SINT;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R8_TYPELESS ]            = DXGI_FORMAT_R8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R8_UNORM ]               = DXGI_FORMAT_R8_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R8_UINT ]                = DXGI_FORMAT_R8_UINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R8_SNORM ]               = DXGI_FORMAT_R8_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_R8_SINT ]                = DXGI_FORMAT_R8_SINT;
-        FmtToDXGIFmtMap[ TEX_FORMAT_A8_UNORM ]               = DXGI_FORMAT_A8_UNORM;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R1_UNORM ]               = DXGI_FORMAT_R1_UNORM ;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RGB9E5_SHAREDEXP ]       = DXGI_FORMAT_R9G9B9E5_SHAREDEXP;
-        FmtToDXGIFmtMap[ TEX_FORMAT_RG8_B8G8_UNORM ]         = DXGI_FORMAT_R8G8_B8G8_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_G8R8_G8B8_UNORM ]        = DXGI_FORMAT_G8R8_G8B8_UNORM;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC1_TYPELESS ]           = DXGI_FORMAT_BC1_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC1_UNORM ]              = DXGI_FORMAT_BC1_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC1_UNORM_SRGB ]         = DXGI_FORMAT_BC1_UNORM_SRGB;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC2_TYPELESS ]           = DXGI_FORMAT_BC2_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC2_UNORM ]              = DXGI_FORMAT_BC2_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC2_UNORM_SRGB ]         = DXGI_FORMAT_BC2_UNORM_SRGB;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC3_TYPELESS ]           = DXGI_FORMAT_BC3_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC3_UNORM ]              = DXGI_FORMAT_BC3_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC3_UNORM_SRGB ]         = DXGI_FORMAT_BC3_UNORM_SRGB;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC4_TYPELESS ]           = DXGI_FORMAT_BC4_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC4_UNORM ]              = DXGI_FORMAT_BC4_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC4_SNORM ]              = DXGI_FORMAT_BC4_SNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC5_TYPELESS ]           = DXGI_FORMAT_BC5_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC5_UNORM ]              = DXGI_FORMAT_BC5_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC5_SNORM ]              = DXGI_FORMAT_BC5_SNORM;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_B5G6R5_UNORM ]           = DXGI_FORMAT_B5G6R5_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_B5G5R5A1_UNORM ]         = DXGI_FORMAT_B5G5R5A1_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_UNORM ]            = DXGI_FORMAT_B8G8R8A8_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_UNORM ]            = DXGI_FORMAT_B8G8R8X8_UNORM;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_R10G10B10_XR_BIAS_A2_UNORM ]= DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_TYPELESS ]         = DXGI_FORMAT_B8G8R8A8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRA8_UNORM_SRGB ]       = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_TYPELESS ]         = DXGI_FORMAT_B8G8R8X8_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BGRX8_UNORM_SRGB ]       = DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
-
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_TYPELESS ]          = DXGI_FORMAT_BC6H_TYPELESS;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_UF16 ]              = DXGI_FORMAT_BC6H_UF16;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC6H_SF16 ]              = DXGI_FORMAT_BC6H_SF16;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC7_TYPELESS ]           = DXGI_FORMAT_BC7_TYPELESS ;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC7_UNORM ]              = DXGI_FORMAT_BC7_UNORM;
-        FmtToDXGIFmtMap[ TEX_FORMAT_BC7_UNORM_SRGB ]         = DXGI_FORMAT_BC7_UNORM_SRGB;
-        
+        // clang-format off
+        FmtToDXGIFmtMap[TEX_FORMAT_UNKNOWN]                = DXGI_FORMAT_UNKNOWN;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_TYPELESS]        = DXGI_FORMAT_R32G32B32A32_TYPELESS; 
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_FLOAT]           = DXGI_FORMAT_R32G32B32A32_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_UINT]            = DXGI_FORMAT_R32G32B32A32_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA32_SINT]            = DXGI_FORMAT_R32G32B32A32_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB32_TYPELESS]         = DXGI_FORMAT_R32G32B32_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB32_FLOAT]            = DXGI_FORMAT_R32G32B32_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB32_UINT]             = DXGI_FORMAT_R32G32B32_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB32_SINT]             = DXGI_FORMAT_R32G32B32_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_TYPELESS]        = DXGI_FORMAT_R16G16B16A16_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_FLOAT]           = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_UNORM]           = DXGI_FORMAT_R16G16B16A16_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_UINT]            = DXGI_FORMAT_R16G16B16A16_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_SNORM]           = DXGI_FORMAT_R16G16B16A16_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA16_SINT]            = DXGI_FORMAT_R16G16B16A16_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RG32_TYPELESS]          = DXGI_FORMAT_R32G32_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG32_FLOAT]             = DXGI_FORMAT_R32G32_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG32_UINT]              = DXGI_FORMAT_R32G32_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG32_SINT]              = DXGI_FORMAT_R32G32_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R32G8X24_TYPELESS]      = DXGI_FORMAT_R32G8X24_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_D32_FLOAT_S8X24_UINT]   = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R32_FLOAT_X8X24_TYPELESS]= DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_X32_TYPELESS_G8X24_UINT]= DXGI_FORMAT_X32_TYPELESS_G8X24_UINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_TYPELESS]       = DXGI_FORMAT_R10G10B10A2_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_UNORM]          = DXGI_FORMAT_R10G10B10A2_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB10A2_UINT]           = DXGI_FORMAT_R10G10B10A2_UINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R11G11B10_FLOAT]        = DXGI_FORMAT_R11G11B10_FLOAT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_TYPELESS]         = DXGI_FORMAT_R8G8B8A8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UNORM]            = DXGI_FORMAT_R8G8B8A8_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UNORM_SRGB]       = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_UINT]             = DXGI_FORMAT_R8G8B8A8_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_SNORM]            = DXGI_FORMAT_R8G8B8A8_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGBA8_SINT]             = DXGI_FORMAT_R8G8B8A8_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_TYPELESS]          = DXGI_FORMAT_R16G16_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_FLOAT]             = DXGI_FORMAT_R16G16_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_UNORM]             = DXGI_FORMAT_R16G16_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_UINT]              = DXGI_FORMAT_R16G16_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_SNORM]             = DXGI_FORMAT_R16G16_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG16_SINT]              = DXGI_FORMAT_R16G16_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R32_TYPELESS]           = DXGI_FORMAT_R32_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_D32_FLOAT]              = DXGI_FORMAT_D32_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R32_FLOAT]              = DXGI_FORMAT_R32_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R32_UINT]               = DXGI_FORMAT_R32_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R32_SINT]               = DXGI_FORMAT_R32_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R24G8_TYPELESS]         = DXGI_FORMAT_R24G8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_D24_UNORM_S8_UINT]      = DXGI_FORMAT_D24_UNORM_S8_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R24_UNORM_X8_TYPELESS]  = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_X24_TYPELESS_G8_UINT]   = DXGI_FORMAT_X24_TYPELESS_G8_UINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_TYPELESS]           = DXGI_FORMAT_R8G8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_UNORM]              = DXGI_FORMAT_R8G8_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_UINT]               = DXGI_FORMAT_R8G8_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_SNORM]              = DXGI_FORMAT_R8G8_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_SINT]               = DXGI_FORMAT_R8G8_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_TYPELESS]           = DXGI_FORMAT_R16_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_FLOAT]              = DXGI_FORMAT_R16_FLOAT;
+        FmtToDXGIFmtMap[TEX_FORMAT_D16_UNORM]              = DXGI_FORMAT_D16_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_UNORM]              = DXGI_FORMAT_R16_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_UINT]               = DXGI_FORMAT_R16_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_SNORM]              = DXGI_FORMAT_R16_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_R16_SINT]               = DXGI_FORMAT_R16_SINT;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R8_TYPELESS]            = DXGI_FORMAT_R8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_R8_UNORM]               = DXGI_FORMAT_R8_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_R8_UINT]                = DXGI_FORMAT_R8_UINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_R8_SNORM]               = DXGI_FORMAT_R8_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_R8_SINT]                = DXGI_FORMAT_R8_SINT;
+        FmtToDXGIFmtMap[TEX_FORMAT_A8_UNORM]               = DXGI_FORMAT_A8_UNORM;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R1_UNORM]               = DXGI_FORMAT_R1_UNORM ;
+        FmtToDXGIFmtMap[TEX_FORMAT_RGB9E5_SHAREDEXP]       = DXGI_FORMAT_R9G9B9E5_SHAREDEXP;
+        FmtToDXGIFmtMap[TEX_FORMAT_RG8_B8G8_UNORM]         = DXGI_FORMAT_R8G8_B8G8_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_G8R8_G8B8_UNORM]        = DXGI_FORMAT_G8R8_G8B8_UNORM;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_BC1_TYPELESS]           = DXGI_FORMAT_BC1_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC1_UNORM]              = DXGI_FORMAT_BC1_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC1_UNORM_SRGB]         = DXGI_FORMAT_BC1_UNORM_SRGB;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC2_TYPELESS]           = DXGI_FORMAT_BC2_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC2_UNORM]              = DXGI_FORMAT_BC2_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC2_UNORM_SRGB]         = DXGI_FORMAT_BC2_UNORM_SRGB;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC3_TYPELESS]           = DXGI_FORMAT_BC3_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC3_UNORM]              = DXGI_FORMAT_BC3_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC3_UNORM_SRGB]         = DXGI_FORMAT_BC3_UNORM_SRGB;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC4_TYPELESS]           = DXGI_FORMAT_BC4_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC4_UNORM]              = DXGI_FORMAT_BC4_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC4_SNORM]              = DXGI_FORMAT_BC4_SNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC5_TYPELESS]           = DXGI_FORMAT_BC5_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC5_UNORM]              = DXGI_FORMAT_BC5_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC5_SNORM]              = DXGI_FORMAT_BC5_SNORM;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_B5G6R5_UNORM]           = DXGI_FORMAT_B5G6R5_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_B5G5R5A1_UNORM]         = DXGI_FORMAT_B5G5R5A1_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_UNORM]            = DXGI_FORMAT_B8G8R8A8_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_UNORM]            = DXGI_FORMAT_B8G8R8X8_UNORM;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_R10G10B10_XR_BIAS_A2_UNORM]= DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_TYPELESS]         = DXGI_FORMAT_B8G8R8A8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRA8_UNORM_SRGB]       = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_TYPELESS]         = DXGI_FORMAT_B8G8R8X8_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BGRX8_UNORM_SRGB]       = DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+
+        FmtToDXGIFmtMap[TEX_FORMAT_BC6H_TYPELESS]          = DXGI_FORMAT_BC6H_TYPELESS;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC6H_UF16]              = DXGI_FORMAT_BC6H_UF16;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC6H_SF16]              = DXGI_FORMAT_BC6H_SF16;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC7_TYPELESS]           = DXGI_FORMAT_BC7_TYPELESS ;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC7_UNORM]              = DXGI_FORMAT_BC7_UNORM;
+        FmtToDXGIFmtMap[TEX_FORMAT_BC7_UNORM_SRGB]         = DXGI_FORMAT_BC7_UNORM_SRGB;
+        // clang-format on
+
         bFormatMapIntialized = true;
     }
 
-    if( TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS )
+    if (TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS)
     {
         auto DXGIFormat = FmtToDXGIFmtMap[TexFormat];
-        VERIFY( TexFormat == TEX_FORMAT_UNKNOWN || DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format" );
-        if( BindFlags != 0 )
-            DXGIFormat = CorrectDXGIFormat( DXGIFormat, BindFlags );
+        VERIFY(TexFormat == TEX_FORMAT_UNKNOWN || DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format");
+        if (BindFlags != 0)
+            DXGIFormat = CorrectDXGIFormat(DXGIFormat, BindFlags);
         return DXGIFormat;
     }
     else
     {
-        UNEXPECTED( "Texture format (", TexFormat, ") is out of allowed range [0, ", TEX_FORMAT_NUM_FORMATS-1, "]" );
+        UNEXPECTED("Texture format (", TexFormat, ") is out of allowed range [0, ", TEX_FORMAT_NUM_FORMATS - 1, "]");
         return DXGI_FORMAT_UNKNOWN;
     }
 }
@@ -418,7 +420,7 @@ class DXGIFmtToFmtMapInitializer
 public:
     DXGIFmtToFmtMapInitializer(TEXTURE_FORMAT DXGIFmtToFmtMap[])
     {
-        for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast<TEXTURE_FORMAT>(fmt +1))
+        for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast<TEXTURE_FORMAT>(fmt + 1))
         {
             auto DXGIFmt = TexFormatToDXGI_Format(fmt);
             VERIFY_EXPR(DXGIFmt <= DXGI_FORMAT_B4G4R4A4_UNORM);
@@ -430,21 +432,21 @@ public:
 TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat)
 {
     static_assert(DXGI_FORMAT_B4G4R4A4_UNORM == 115, "Unexpected DXGI format value");
-    static TEXTURE_FORMAT DXGIFmtToFmtMap[DXGI_FORMAT_B4G4R4A4_UNORM+1];
+    static TEXTURE_FORMAT             DXGIFmtToFmtMap[DXGI_FORMAT_B4G4R4A4_UNORM + 1];
     static DXGIFmtToFmtMapInitializer Initializer(DXGIFmtToFmtMap);
 
-    if( DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB )
+    if (DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB)
     {
         auto Format = DXGIFmtToFmtMap[DXGIFormat];
-        VERIFY( DXGIFormat == DXGI_FORMAT_UNKNOWN || Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format" );
+        VERIFY(DXGIFormat == DXGI_FORMAT_UNKNOWN || Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format");
         VERIFY_EXPR(DXGIFormat == TexFormatToDXGI_Format(Format));
         return Format;
     }
     else
     {
-        UNEXPECTED( "DXGI texture format (", DXGIFormat, ") is out of allowed range [0, ", DXGI_FORMAT_BC7_UNORM_SRGB, "]" );
+        UNEXPECTED("DXGI texture format (", DXGIFormat, ") is out of allowed range [0, ", DXGI_FORMAT_BC7_UNORM_SRGB, "]");
         return TEX_FORMAT_UNKNOWN;
     }
 }
 
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp
index 02281be7..12bd69c0 100644
--- a/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp
+++ b/Graphics/GraphicsEngineD3DBase/src/ShaderD3DBase.cpp
@@ -33,92 +33,93 @@
 namespace Diligent
 {
 
-static const Char* g_HLSLDefinitions = 
-{
-    #include "HLSLDefinitions_inc.fxh"
+static const Char* g_HLSLDefinitions =
+    {
+#include "HLSLDefinitions_inc.fxh"
 };
 
 class D3DIncludeImpl : public ID3DInclude
 {
 public:
-    D3DIncludeImpl(IShaderSourceInputStreamFactory* pStreamFactory) : 
-        m_pStreamFactory(pStreamFactory)
+    D3DIncludeImpl(IShaderSourceInputStreamFactory* pStreamFactory) :
+        m_pStreamFactory{pStreamFactory}
     {
-
     }
 
-    STDMETHOD( Open )(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID* ppData, UINT* pBytes)
+    STDMETHOD(Open)
+    (THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID* ppData, UINT* pBytes)
     {
         RefCntAutoPtr<IFileStream> pSourceStream;
-        m_pStreamFactory->CreateInputStream( pFileName, &pSourceStream );
-        if( pSourceStream == nullptr )
+        m_pStreamFactory->CreateInputStream(pFileName, &pSourceStream);
+        if (pSourceStream == nullptr)
         {
-            LOG_ERROR( "Failed to open shader include file ", pFileName, ". Check that the file exists" );
+            LOG_ERROR("Failed to open shader include file ", pFileName, ". Check that the file exists");
             return E_FAIL;
         }
 
-        RefCntAutoPtr<IDataBlob> pFileData( MakeNewRCObj<DataBlobImpl>()(0) );
-        pSourceStream->Read( pFileData );
+        RefCntAutoPtr<IDataBlob> pFileData(MakeNewRCObj<DataBlobImpl>()(0));
+        pSourceStream->Read(pFileData);
         *ppData = pFileData->GetDataPtr();
-        *pBytes = static_cast<UINT>( pFileData->GetSize() );
+        *pBytes = static_cast<UINT>(pFileData->GetSize());
 
-        m_DataBlobs.insert( std::make_pair(*ppData, pFileData) );
+        m_DataBlobs.insert(std::make_pair(*ppData, pFileData));
 
         return S_OK;
     }
 
-    STDMETHOD( Close )(THIS_ LPCVOID pData)
+    STDMETHOD(Close)
+    (THIS_ LPCVOID pData)
     {
-        m_DataBlobs.erase( pData );
+        m_DataBlobs.erase(pData);
         return S_OK;
     }
 
 private:
-    IShaderSourceInputStreamFactory *m_pStreamFactory;
-    std::unordered_map< LPCVOID, RefCntAutoPtr<IDataBlob> > m_DataBlobs;
+    IShaderSourceInputStreamFactory*                      m_pStreamFactory;
+    std::unordered_map<LPCVOID, RefCntAutoPtr<IDataBlob>> m_DataBlobs;
 };
 
-static HRESULT CompileShader(const char*                        Source,
-                             LPCSTR                             strFunctionName,
-                             const D3D_SHADER_MACRO*            pDefines, 
-                             IShaderSourceInputStreamFactory*   pIncludeStreamFactory,
-                             LPCSTR                             profile, 
-                             ID3DBlob**                         ppBlobOut,
-                             ID3DBlob**                         ppCompilerOutput)
+static HRESULT CompileShader(const char*                      Source,
+                             LPCSTR                           strFunctionName,
+                             const D3D_SHADER_MACRO*          pDefines,
+                             IShaderSourceInputStreamFactory* pIncludeStreamFactory,
+                             LPCSTR                           profile,
+                             ID3DBlob**                       ppBlobOut,
+                             ID3DBlob**                       ppCompilerOutput)
 {
     DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
-#if defined( DEBUG ) || defined( _DEBUG )
+#if defined(DEBUG) || defined(_DEBUG)
     // Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
-    // Setting this flag improves the shader debugging experience, but still allows 
-    // the shaders to be optimized and to run exactly the way they will run in 
+    // Setting this flag improves the shader debugging experience, but still allows
+    // the shaders to be optimized and to run exactly the way they will run in
     // the release configuration of this program.
     dwShaderFlags |= D3DCOMPILE_DEBUG;
 #else
-    // Warning: do not use this flag as it causes shader compiler to fail the compilation and 
+    // Warning: do not use this flag as it causes shader compiler to fail the compilation and
     // report strange errors:
     // dwShaderFlags |= D3D10_SHADER_OPTIMIZATION_LEVEL3;
 #endif
-	HRESULT hr;
-//	do
-//	{
-        auto SourceLen = strlen(Source);
-         
-        D3DIncludeImpl IncludeImpl(pIncludeStreamFactory);
-        hr = D3DCompile( Source, SourceLen, NULL, pDefines, &IncludeImpl, strFunctionName, profile, dwShaderFlags, 0, ppBlobOut, ppCompilerOutput);
-       
-//		if( FAILED(hr) || errors )
-//		{
-//			if( FAILED(hr) 
-//#if PLATFORM_WIN32
-//                && IDRETRY != MessageBoxW( NULL, L"Failed to compile shader", L"FX Error", MB_ICONERROR | (Source == nullptr ? MB_ABORTRETRYIGNORE : 0) ) 
-//#endif
-//                )
-//			{
-//				break;
-//			}
-//		}
-//	} while( FAILED(hr) );
-	return hr;
+    HRESULT hr;
+    //	do
+    //	{
+    auto SourceLen = strlen(Source);
+
+    D3DIncludeImpl IncludeImpl(pIncludeStreamFactory);
+    hr = D3DCompile(Source, SourceLen, NULL, pDefines, &IncludeImpl, strFunctionName, profile, dwShaderFlags, 0, ppBlobOut, ppCompilerOutput);
+
+    //		if( FAILED(hr) || errors )
+    //		{
+    //			if( FAILED(hr)
+    //#if PLATFORM_WIN32
+    //                && IDRETRY != MessageBoxW( NULL, L"Failed to compile shader", L"FX Error", MB_ICONERROR | (Source == nullptr ? MB_ABORTRETRYIGNORE : 0) )
+    //#endif
+    //                )
+    //			{
+    //				break;
+    //			}
+    //		}
+    //	} while( FAILED(hr) );
+    return hr;
 }
 
 ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* ShaderModel)
@@ -131,14 +132,16 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade
         std::string strShaderProfile;
         switch (ShaderCI.Desc.ShaderType)
         {
+            // clang-format off
             case SHADER_TYPE_VERTEX:  strShaderProfile="vs"; break;
             case SHADER_TYPE_PIXEL:   strShaderProfile="ps"; break;
             case SHADER_TYPE_GEOMETRY:strShaderProfile="gs"; break;
             case SHADER_TYPE_HULL:    strShaderProfile="hs"; break;
             case SHADER_TYPE_DOMAIN:  strShaderProfile="ds"; break;
             case SHADER_TYPE_COMPUTE: strShaderProfile="cs"; break;
+                // clang-format on
 
-            default: UNEXPECTED( "Unknown shader type" );
+            default: UNEXPECTED("Unknown shader type");
         }
         strShaderProfile += "_";
         strShaderProfile += ShaderModel;
@@ -160,33 +163,33 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade
             pSourceStream->Read(pFileData);
             // Null terminator is not read from the stream!
             auto* FileDataPtr = reinterpret_cast<Char*>(pFileData->GetDataPtr());
-            auto Size = pFileData->GetSize();
+            auto  Size        = pFileData->GetSize();
             ShaderSource.append(FileDataPtr, FileDataPtr + Size / sizeof(*FileDataPtr));
         }
 
-        const D3D_SHADER_MACRO *pDefines = nullptr;
+        const D3D_SHADER_MACRO*       pDefines = nullptr;
         std::vector<D3D_SHADER_MACRO> D3DMacros;
         if (ShaderCI.Macros)
         {
             for (auto* pCurrMacro = ShaderCI.Macros; pCurrMacro->Name && pCurrMacro->Definition; ++pCurrMacro)
             {
-                D3DMacros.push_back({ pCurrMacro->Name, pCurrMacro->Definition });
+                D3DMacros.push_back({pCurrMacro->Name, pCurrMacro->Definition});
             }
-            D3DMacros.push_back({ nullptr, nullptr });
+            D3DMacros.push_back({nullptr, nullptr});
             pDefines = D3DMacros.data();
         }
 
         DEV_CHECK_ERR(ShaderCI.EntryPoint != nullptr, "Entry point must not be null");
         CComPtr<ID3DBlob> errors;
-        auto hr = CompileShader(ShaderSource.c_str(), ShaderCI.EntryPoint, pDefines, ShaderCI.pShaderSourceStreamFactory, strShaderProfile.c_str(), &m_pShaderByteCode, &errors);
+        auto              hr = CompileShader(ShaderSource.c_str(), ShaderCI.EntryPoint, pDefines, ShaderCI.pShaderSourceStreamFactory, strShaderProfile.c_str(), &m_pShaderByteCode, &errors);
 
         const char* CompilerMsg = errors ? reinterpret_cast<const char*>(errors->GetBufferPointer()) : nullptr;
         if (CompilerMsg != nullptr && ShaderCI.ppCompilerOutput != nullptr)
         {
-            auto ErrorMsgLen = strlen(CompilerMsg);
-            auto *pOutputDataBlob = MakeNewRCObj<DataBlobImpl>()(ErrorMsgLen + 1 + ShaderSource.length() + 1);
-            char* DataPtr = reinterpret_cast<char*>(pOutputDataBlob->GetDataPtr());
-            memcpy(DataPtr, CompilerMsg, ErrorMsgLen+1);
+            auto  ErrorMsgLen     = strlen(CompilerMsg);
+            auto* pOutputDataBlob = MakeNewRCObj<DataBlobImpl>()(ErrorMsgLen + 1 + ShaderSource.length() + 1);
+            char* DataPtr         = reinterpret_cast<char*>(pOutputDataBlob->GetDataPtr());
+            memcpy(DataPtr, CompilerMsg, ErrorMsgLen + 1);
             memcpy(DataPtr + ErrorMsgLen + 1, ShaderSource.data(), ShaderSource.length() + 1);
             pOutputDataBlob->QueryInterface(IID_DataBlob, reinterpret_cast<IObject**>(ShaderCI.ppCompilerOutput));
         }
@@ -194,13 +197,13 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade
         if (FAILED(hr))
         {
             ComErrorDesc ErrDesc(hr);
-            if(ShaderCI.ppCompilerOutput != nullptr)
+            if (ShaderCI.ppCompilerOutput != nullptr)
             {
-                LOG_ERROR_AND_THROW("Failed to compile D3D shader \"",  (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), ").");
+                LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), ").");
             }
             else
             {
-                LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), "):\n", (CompilerMsg != nullptr ? CompilerMsg : "<no compiler log available>") );
+                LOG_ERROR_AND_THROW("Failed to compile D3D shader \"", (ShaderCI.Desc.Name != nullptr ? ShaderCI.Desc.Name : ""), "\" (", ErrDesc.Get(), "):\n", (CompilerMsg != nullptr ? CompilerMsg : "<no compiler log available>"));
             }
         }
     }
@@ -216,4 +219,4 @@ ShaderD3DBase::ShaderD3DBase(const ShaderCreateInfo& ShaderCI, const char* Shade
     }
 }
 
-}
+} // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
index 224ed75a..ef144b63 100644
--- a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
+++ b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
@@ -34,31 +34,32 @@ namespace Diligent
 
 ShaderResources::~ShaderResources()
 {
-    for(Uint32 n=0; n < GetNumCBs(); ++n)
+    for (Uint32 n = 0; n < GetNumCBs(); ++n)
         GetCB(n).~D3DShaderResourceAttribs();
 
-    for(Uint32 n=0; n < GetNumTexSRV(); ++n)
+    for (Uint32 n = 0; n < GetNumTexSRV(); ++n)
         GetTexSRV(n).~D3DShaderResourceAttribs();
 
-    for(Uint32 n=0; n < GetNumTexUAV(); ++n)
+    for (Uint32 n = 0; n < GetNumTexUAV(); ++n)
         GetTexUAV(n).~D3DShaderResourceAttribs();
 
-    for(Uint32 n=0; n < GetNumBufSRV(); ++n)
+    for (Uint32 n = 0; n < GetNumBufSRV(); ++n)
         GetBufSRV(n).~D3DShaderResourceAttribs();
 
-    for(Uint32 n=0; n < GetNumBufUAV(); ++n)
+    for (Uint32 n = 0; n < GetNumBufUAV(); ++n)
         GetBufUAV(n).~D3DShaderResourceAttribs();
 
-    for(Uint32 n=0; n < GetNumSamplers(); ++n)
+    for (Uint32 n = 0; n < GetNumSamplers(); ++n)
         GetSampler(n).~D3DShaderResourceAttribs();
 }
 
-void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator, 
+void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
                                      const D3DShaderResourceCounters& ResCounters,
                                      size_t                           ResourceNamesPoolSize)
 {
     Uint32 CurrentOffset = 0;
-    auto AdvanceOffset = [&CurrentOffset](Uint32 NumResources)
+
+    auto AdvanceOffset = [&CurrentOffset](Uint32 NumResources) //
     {
         constexpr Uint32 MaxOffset = std::numeric_limits<OffsetType>::max();
         VERIFY(CurrentOffset <= MaxOffset, "Current offser (", CurrentOffset, ") exceeds max allowed value (", MaxOffset, ")");
@@ -67,6 +68,7 @@ void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
         return Offset;
     };
 
+    // clang-format off
     auto CBOffset    = AdvanceOffset(ResCounters.NumCBs);       (void)CBOffset; // To suppress warning
     m_TexSRVOffset   = AdvanceOffset(ResCounters.NumTexSRVs);
     m_TexUAVOffset   = AdvanceOffset(ResCounters.NumTexUAVs);
@@ -84,27 +86,30 @@ void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
     VERIFY_EXPR(GetNumBufSRV()  == ResCounters.NumBufSRVs);
     VERIFY_EXPR(GetNumBufUAV()  == ResCounters.NumBufUAVs);
     VERIFY_EXPR(GetNumSamplers()== ResCounters.NumSamplers);
+    // clang-format on
 
-    if( MemorySize )
+    if (MemorySize)
     {
-        auto* pRawMem = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize );
-        m_MemoryBuffer = std::unique_ptr< void, STDDeleterRawMem<void> >(pRawMem, Allocator);
+        auto* pRawMem   = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize);
+        m_MemoryBuffer  = std::unique_ptr<void, STDDeleterRawMem<void>>(pRawMem, Allocator);
         char* NamesPool = reinterpret_cast<char*>(reinterpret_cast<D3DShaderResourceAttribs*>(pRawMem) + m_TotalResources);
         m_ResourceNames.AssignMemory(NamesPool, ResourceNamesPoolSize);
-    }    
+    }
 }
 
 SHADER_RESOURCE_VARIABLE_TYPE ShaderResources::FindVariableType(const D3DShaderResourceAttribs&   ResourceAttribs,
-                                                                const PipelineResourceLayoutDesc& ResourceLayout)const
+                                                                const PipelineResourceLayoutDesc& ResourceLayout) const
 {
     if (ResourceAttribs.GetInputType() == D3D_SIT_SAMPLER)
     {
         // Only use CombinedSamplerSuffix when looking for the sampler variable type
-        return GetShaderVariableType(m_ShaderType, ResourceLayout.DefaultVariableType, ResourceLayout.Variables, ResourceLayout.NumVariables,
-                                     [&](const char* VarName)
-                                     {
-                                         return StreqSuff(ResourceAttribs.Name, VarName, m_SamplerSuffix);
-                                     });
+        return GetShaderVariableType(
+            m_ShaderType, ResourceLayout.DefaultVariableType, ResourceLayout.Variables, ResourceLayout.NumVariables,
+            [&](const char* VarName) //
+            {
+                return StreqSuff(ResourceAttribs.Name, VarName, m_SamplerSuffix);
+            } //
+        );
     }
     else
     {
@@ -114,11 +119,11 @@ SHADER_RESOURCE_VARIABLE_TYPE ShaderResources::FindVariableType(const D3DShaderR
 
 Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
                                          const PipelineResourceLayoutDesc& ResourceLayoutDesc,
-                                         bool                              LogStaticSamplerArrayError)const
+                                         bool                              LogStaticSamplerArrayError) const
 {
     VERIFY(ResourceAttribs.GetInputType() == D3D_SIT_SAMPLER, "Sampler is expected");
 
-    auto StaticSamplerInd = 
+    auto StaticSamplerInd =
         Diligent::FindStaticSampler(ResourceLayoutDesc.StaticSamplers,
                                     ResourceLayoutDesc.NumStaticSamplers,
                                     m_ShaderType,
@@ -134,9 +139,9 @@ Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs&   Resou
         {
             if (LogStaticSamplerArrayError)
             {
-                LOG_ERROR_MESSAGE("Static sampler '", ResourceAttribs.Name, '[', ResourceAttribs.BindCount, "]' will be ignored because static "
-                                  "sampler arrays are not allowed in shader model 5.1 and above. Compile the shader using shader "
-                                  "model 5.0 or use non-array sampler variable.");
+                LOG_ERROR_MESSAGE("Static sampler '", ResourceAttribs.Name, '[', ResourceAttribs.BindCount,
+                                  "]' will be ignored because static sampler arrays are not allowed in shader model 5.1 and above. "
+                                  "Compile the shader using shader model 5.0 or use non-array sampler variable.");
             }
             StaticSamplerInd = -1;
         }
@@ -149,19 +154,19 @@ Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs&   Resou
 D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResourceLayoutDesc&    ResourceLayout,
                                                           const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
                                                           Uint32                               NumAllowedTypes,
-                                                          bool                                 CountStaticSamplers)const noexcept
+                                                          bool                                 CountStaticSamplers) const noexcept
 {
     auto AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes);
 
     D3DShaderResourceCounters Counters;
     ProcessResources(
-        [&](const D3DShaderResourceAttribs& CB, Uint32)
+        [&](const D3DShaderResourceAttribs& CB, Uint32) //
         {
             auto VarType = FindVariableType(CB, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
                 ++Counters.NumCBs;
         },
-        [&](const D3DShaderResourceAttribs& Sam, Uint32)
+        [&](const D3DShaderResourceAttribs& Sam, Uint32) //
         {
             auto VarType = FindVariableType(Sam, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
@@ -175,30 +180,30 @@ D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResource
                 ++Counters.NumSamplers;
             }
         },
-        [&](const D3DShaderResourceAttribs& TexSRV, Uint32)
+        [&](const D3DShaderResourceAttribs& TexSRV, Uint32) //
         {
             auto VarType = FindVariableType(TexSRV, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
                 ++Counters.NumTexSRVs;
         },
-        [&](const D3DShaderResourceAttribs& TexUAV, Uint32)
+        [&](const D3DShaderResourceAttribs& TexUAV, Uint32) //
         {
             auto VarType = FindVariableType(TexUAV, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
                 ++Counters.NumTexUAVs;
         },
-        [&](const D3DShaderResourceAttribs& BufSRV, Uint32)
+        [&](const D3DShaderResourceAttribs& BufSRV, Uint32) //
         {
             auto VarType = FindVariableType(BufSRV, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
                 ++Counters.NumBufSRVs;
         },
-        [&](const D3DShaderResourceAttribs& BufUAV, Uint32)
+        [&](const D3DShaderResourceAttribs& BufUAV, Uint32) //
         {
             auto VarType = FindVariableType(BufUAV, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
                 ++Counters.NumBufUAVs;
-        }
+        } //
     );
 
     return Counters;
@@ -209,10 +214,10 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
                                               const ShaderResources* const      pShaderResources[],
                                               Uint32                            NumShaders)
 {
-    auto GetAllowedShadersString = [&](SHADER_TYPE ShaderStages)
+    auto GetAllowedShadersString = [&](SHADER_TYPE ShaderStages) //
     {
         std::string ShadersStr;
-        for (Uint32 s=0; s < NumShaders; ++s)
+        for (Uint32 s = 0; s < NumShaders; ++s)
         {
             const auto& Resources = *pShaderResources[s];
             if ((ShaderStages & Resources.GetShaderType()) != 0)
@@ -240,15 +245,15 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
         for (Uint32 s = 0; s < NumShaders && !VariableFound; ++s)
         {
             const auto& Resources = *pShaderResources[s];
-            if( (VarDesc.ShaderStages & Resources.GetShaderType()) == 0)
+            if ((VarDesc.ShaderStages & Resources.GetShaderType()) == 0)
                 continue;
-            
+
             const auto UseCombinedTextureSamplers = Resources.IsUsingCombinedTextureSamplers();
-            for (Uint32 n=0; n < Resources.m_TotalResources && !VariableFound; ++n)
+            for (Uint32 n = 0; n < Resources.m_TotalResources && !VariableFound; ++n)
             {
                 const auto& Res = Resources.GetResAttribs(n, Resources.m_TotalResources, 0);
 
-                // Skip samplers if combined texture samplers are used as 
+                // Skip samplers if combined texture samplers are used as
                 // in this case they are not treated as independent variables
                 if (UseCombinedTextureSamplers && Res.GetInputType() == D3D_SIT_SAMPLER)
                     continue;
@@ -275,22 +280,22 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
         }
 
         const auto* TexOrSamName = StSamDesc.SamplerOrTextureName;
-        
+
         bool StaticSamplerFound = false;
         for (Uint32 s = 0; s < NumShaders && !StaticSamplerFound; ++s)
         {
             const auto& Resources = *pShaderResources[s];
-            if ( (StSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
+            if ((StSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
                 continue;
 
             // Look for static sampler.
             // In case HLSL-style combined image samplers are used, the condition is  Sampler.Name == "g_Texture" + "_sampler".
             // Otherwise the condition is  Sampler.Name == "g_Texture_sampler" + "".
             const auto* CombinedSamplerSuffix = Resources.GetCombinedSamplerSuffix();
-            for (Uint32 n=0; n < Resources.GetNumSamplers() && !StaticSamplerFound; ++n)
+            for (Uint32 n = 0; n < Resources.GetNumSamplers() && !StaticSamplerFound; ++n)
             {
                 const auto& Sampler = Resources.GetSampler(n);
-                StaticSamplerFound = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
+                StaticSamplerFound  = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
             }
         }
 
@@ -304,7 +309,7 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
 #endif
 
 
-Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix)const
+Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix) const
 {
     VERIFY_EXPR(SamplerSuffix != nullptr && *SamplerSuffix != 0);
     VERIFY_EXPR(TexSRV.GetInputType() == D3D_SIT_TEXTURE && TexSRV.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER);
@@ -312,94 +317,94 @@ Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& Te
     for (Uint32 s = 0; s < NumSamplers; ++s)
     {
         const auto& Sampler = GetSampler(s);
-        if ( StreqSuff(Sampler.Name, TexSRV.Name, SamplerSuffix) )
+        if (StreqSuff(Sampler.Name, TexSRV.Name, SamplerSuffix))
         {
-            DEV_CHECK_ERR(Sampler.BindCount == TexSRV.BindCount || Sampler.BindCount == 1, "Sampler '", Sampler.Name, "' assigned to texture '", TexSRV.Name, "' must be scalar or have the same array dimension (", TexSRV.BindCount, "). Actual sampler array dimension : ",  Sampler.BindCount);
+            DEV_CHECK_ERR(Sampler.BindCount == TexSRV.BindCount || Sampler.BindCount == 1, "Sampler '", Sampler.Name, "' assigned to texture '", TexSRV.Name, "' must be scalar or have the same array dimension (", TexSRV.BindCount, "). Actual sampler array dimension : ", Sampler.BindCount);
             return s;
         }
     }
     return D3DShaderResourceAttribs::InvalidSamplerId;
 }
 
-bool ShaderResources::IsCompatibleWith(const ShaderResources &Res)const
+bool ShaderResources::IsCompatibleWith(const ShaderResources& Res) const
 {
-    if (GetNumCBs()      != Res.GetNumCBs()    ||
-        GetNumTexSRV()   != Res.GetNumTexSRV() ||
-        GetNumTexUAV()   != Res.GetNumTexUAV() ||
-        GetNumBufSRV()   != Res.GetNumBufSRV() ||
-        GetNumBufUAV()   != Res.GetNumBufUAV() ||
+    if (GetNumCBs() != Res.GetNumCBs() ||
+        GetNumTexSRV() != Res.GetNumTexSRV() ||
+        GetNumTexUAV() != Res.GetNumTexUAV() ||
+        GetNumBufSRV() != Res.GetNumBufSRV() ||
+        GetNumBufUAV() != Res.GetNumBufUAV() ||
         GetNumSamplers() != Res.GetNumSamplers())
         return false;
 
     bool IsCompatible = true;
     ProcessResources(
-        [&](const D3DShaderResourceAttribs& CB, Uint32 n)
+        [&](const D3DShaderResourceAttribs& CB, Uint32 n) //
         {
             if (!CB.IsCompatibleWith(Res.GetCB(n)))
                 IsCompatible = false;
         },
-        [&](const D3DShaderResourceAttribs& Sam, Uint32 n)
+        [&](const D3DShaderResourceAttribs& Sam, Uint32 n) //
         {
             if (!Sam.IsCompatibleWith(Res.GetSampler(n)))
                 IsCompatible = false;
         },
-        [&](const D3DShaderResourceAttribs& TexSRV, Uint32 n)
+        [&](const D3DShaderResourceAttribs& TexSRV, Uint32 n) //
         {
             if (!TexSRV.IsCompatibleWith(Res.GetTexSRV(n)))
                 IsCompatible = false;
         },
-        [&](const D3DShaderResourceAttribs& TexUAV, Uint32 n)
+        [&](const D3DShaderResourceAttribs& TexUAV, Uint32 n) //
         {
             if (!TexUAV.IsCompatibleWith(Res.GetTexUAV(n)))
                 IsCompatible = false;
         },
-        [&](const D3DShaderResourceAttribs& BufSRV, Uint32 n)
+        [&](const D3DShaderResourceAttribs& BufSRV, Uint32 n) //
         {
             if (!BufSRV.IsCompatibleWith(Res.GetBufSRV(n)))
                 IsCompatible = false;
         },
-        [&](const D3DShaderResourceAttribs& BufUAV, Uint32 n)
+        [&](const D3DShaderResourceAttribs& BufUAV, Uint32 n) //
         {
             if (!BufUAV.IsCompatibleWith(Res.GetBufUAV(n)))
                 IsCompatible = false;
-        }
+        } //
     );
     return IsCompatible;
 }
 
-HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const
+HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc() const
 {
     HLSLShaderResourceDesc ResourceDesc;
     ResourceDesc.Name           = Name;
     ResourceDesc.ArraySize      = BindCount;
     ResourceDesc.ShaderRegister = BindPoint;
-    switch(GetInputType())
+    switch (GetInputType())
     {
         case D3D_SIT_CBUFFER:
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_CONSTANT_BUFFER;
-        break;
+            break;
 
         case D3D_SIT_TBUFFER:
-            UNSUPPORTED( "TBuffers are not supported" ); 
+            UNSUPPORTED("TBuffers are not supported");
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_UNKNOWN;
-        break;
+            break;
 
         case D3D_SIT_TEXTURE:
             ResourceDesc.Type = (GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER ? SHADER_RESOURCE_TYPE_BUFFER_SRV : SHADER_RESOURCE_TYPE_TEXTURE_SRV);
-        break;
+            break;
 
         case D3D_SIT_SAMPLER:
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_SAMPLER;
-        break;
+            break;
 
         case D3D_SIT_UAV_RWTYPED:
             ResourceDesc.Type = (GetSRVDimension() == D3D_SRV_DIMENSION_BUFFER ? SHADER_RESOURCE_TYPE_BUFFER_UAV : SHADER_RESOURCE_TYPE_TEXTURE_UAV);
-        break;
+            break;
 
         case D3D_SIT_STRUCTURED:
         case D3D_SIT_BYTEADDRESS:
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_SRV;
-        break;
+            break;
 
         case D3D_SIT_UAV_RWSTRUCTURED:
         case D3D_SIT_UAV_RWBYTEADDRESS:
@@ -407,7 +412,7 @@ HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const
         case D3D_SIT_UAV_CONSUME_STRUCTURED:
         case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_UAV;
-        break;
+            break;
 
         default:
             UNEXPECTED("Unknown input type");
@@ -416,7 +421,7 @@ HLSLShaderResourceDesc D3DShaderResourceAttribs::GetHLSLResourceDesc()const
     return ResourceDesc;
 }
 
-HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index)const
+HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index) const
 {
     DEV_CHECK_ERR(Index < m_TotalResources, "Resource index (", Index, ") is out of range");
     HLSLShaderResourceDesc HLSLResourceDesc = {};
@@ -428,10 +433,10 @@ HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index)c
     return HLSLResourceDesc;
 }
 
-size_t ShaderResources::GetHash()const
+size_t ShaderResources::GetHash() const
 {
     size_t hash = ComputeHash(GetNumCBs(), GetNumTexSRV(), GetNumTexUAV(), GetNumBufSRV(), GetNumBufUAV(), GetNumSamplers());
-    for (Uint32 n=0; n < m_TotalResources; ++n)
+    for (Uint32 n = 0; n < m_TotalResources; ++n)
     {
         const auto& Res = GetResAttribs(n, m_TotalResources, 0);
         HashCombine(hash, Res);
@@ -440,4 +445,4 @@ size_t ShaderResources::GetHash()const
     return hash;
 }
 
-}
+} // namespace Diligent