Merge branch 'master' into ray_tracing

# Conflicts:
#	Graphics/GraphicsEngine/interface/PipelineState.h
#	Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.hpp
#	Graphics/GraphicsEngineVulkan/src/PipelineLayout.cpp
#	Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp

17 files changed, 544 insertions, 382 deletions

diff --git a/Graphics/GraphicsEngineD3D12/include/PipelineStateD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/PipelineStateD3D12Impl.hpp
index a53a625d..fa761fc7 100644
--- a/Graphics/GraphicsEngineD3D12/include/PipelineStateD3D12Impl.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/PipelineStateD3D12Impl.hpp
@@ -38,6 +38,7 @@
 #include "SRBMemoryAllocator.hpp"
 #include "RenderDeviceD3D12Impl.hpp"
 #include "ShaderVariableD3D12.hpp"
+#include "ShaderD3D12Impl.hpp"
 
 namespace Diligent
 {
@@ -50,7 +51,8 @@ class PipelineStateD3D12Impl final : public PipelineStateBase<IPipelineStateD3D1
 public:
     using TPipelineStateBase = PipelineStateBase<IPipelineStateD3D12, RenderDeviceD3D12Impl>;
 
-    PipelineStateD3D12Impl(IReferenceCounters* pRefCounters, RenderDeviceD3D12Impl* pDeviceD3D12, const PipelineStateCreateInfo& CreateInfo);
+    PipelineStateD3D12Impl(IReferenceCounters* pRefCounters, RenderDeviceD3D12Impl* pDeviceD3D12, const GraphicsPipelineStateCreateInfo& CreateInfo);
+    PipelineStateD3D12Impl(IReferenceCounters* pRefCounters, RenderDeviceD3D12Impl* pDeviceD3D12, const ComputePipelineStateCreateInfo& CreateInfo);
     ~PipelineStateD3D12Impl();
 
     virtual void DILIGENT_CALL_TYPE QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface) override final;
@@ -95,19 +97,19 @@ public:
 
     const ShaderResourceLayoutD3D12& GetShaderResLayout(Uint32 ShaderInd) const
     {
-        VERIFY_EXPR(ShaderInd < m_NumShaders);
+        VERIFY_EXPR(ShaderInd < GetNumShaderStages());
         return m_pShaderResourceLayouts[ShaderInd];
     }
 
     const ShaderResourceLayoutD3D12& GetStaticShaderResLayout(Uint32 ShaderInd) const
     {
-        VERIFY_EXPR(ShaderInd < m_NumShaders);
-        return m_pShaderResourceLayouts[m_NumShaders + ShaderInd];
+        VERIFY_EXPR(ShaderInd < GetNumShaderStages());
+        return m_pShaderResourceLayouts[GetNumShaderStages() + ShaderInd];
     }
 
     ShaderResourceCacheD3D12& GetStaticShaderResCache(Uint32 ShaderInd) const
     {
-        VERIFY_EXPR(ShaderInd < m_NumShaders);
+        VERIFY_EXPR(ShaderInd < GetNumShaderStages());
         return m_pStaticResourceCaches[ShaderInd];
     }
 
@@ -119,15 +121,34 @@ public:
     }
 
 private:
+    struct D3D12PipelineShaderStageInfo
+    {
+        const SHADER_TYPE      Type;
+        ShaderD3D12Impl* const pShader;
+        D3D12PipelineShaderStageInfo(SHADER_TYPE      _Type,
+                                     ShaderD3D12Impl* _pShader) :
+            Type{_Type},
+            pShader{_pShader}
+        {}
+    };
+
+    template <typename PSOCreateInfoType>
+    void InitInternalObjects(const PSOCreateInfoType& CreateInfo, std::vector<D3D12PipelineShaderStageInfo>& ShaderStages);
+
+    void InitResourceLayouts(const PipelineStateCreateInfo&             CreateInfo,
+                             std::vector<D3D12PipelineShaderStageInfo>& ShaderStages);
+
+    void Destruct();
+
     CComPtr<ID3D12PipelineState> m_pd3d12PSO;
     RootSignature                m_RootSig;
 
     // Must be defined before default SRB
     SRBMemoryAllocator m_SRBMemAllocator;
 
-    ShaderResourceLayoutD3D12*  m_pShaderResourceLayouts = nullptr;
-    ShaderResourceCacheD3D12*   m_pStaticResourceCaches  = nullptr;
-    ShaderVariableManagerD3D12* m_pStaticVarManagers     = nullptr;
+    ShaderResourceLayoutD3D12*  m_pShaderResourceLayouts = nullptr; // [m_NumShaderStages * 2]
+    ShaderResourceCacheD3D12*   m_pStaticResourceCaches  = nullptr; // [m_NumShaderStages]
+    ShaderVariableManagerD3D12* m_pStaticVarManagers     = nullptr; // [m_NumShaderStages]
 
     // Resource layout index in m_pShaderResourceLayouts array for every shader stage,
     // indexed by the shader type pipeline index (returned by GetShaderTypePipelineIndex)
diff --git a/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp
index 4dfc86c7..7bdc7801 100644
--- a/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp
@@ -62,8 +62,11 @@ public:
 
     virtual void DILIGENT_CALL_TYPE QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface) override final;
 
-    /// Implementation of IRenderDevice::CreatePipelineState() in Direct3D12 backend.
-    virtual void DILIGENT_CALL_TYPE CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState) override final;
+    /// Implementation of IRenderDevice::CreateGraphicsPipelineState() in Direct3D12 backend.
+    virtual void DILIGENT_CALL_TYPE CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState) override final;
+
+    /// Implementation of IRenderDevice::CreateComputePipelineState() in Direct3D12 backend.
+    virtual void DILIGENT_CALL_TYPE CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState) override final;
 
     /// Implementation of IRenderDevice::CreateBuffer() in Direct3D12 backend.
     virtual void DILIGENT_CALL_TYPE CreateBuffer(const BufferDesc& BuffDesc,
@@ -174,6 +177,9 @@ public:
     D3D_FEATURE_LEVEL GetD3DFeatureLevel() const;
 
 private:
+    template <typename PSOCreateInfoType>
+    void CreatePipelineState(const PSOCreateInfoType& PSOCreateInfo, IPipelineState** ppPipelineState);
+
     virtual void TestTextureFormat(TEXTURE_FORMAT TexFormat) override final;
     void         FreeCommandContext(PooledCommandContext&& Ctx);
 
diff --git a/Graphics/GraphicsEngineD3D12/include/RootSignature.hpp b/Graphics/GraphicsEngineD3D12/include/RootSignature.hpp
index 2bf6d0b3..232bce65 100644
--- a/Graphics/GraphicsEngineD3D12/include/RootSignature.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/RootSignature.hpp
@@ -302,7 +302,7 @@ class RootSignature
 public:
     RootSignature();
 
-    void AllocateStaticSamplers(const PipelineResourceLayoutDesc& ResourceLayout);
+    void AllocateImmutableSamplers(const PipelineResourceLayoutDesc& ResourceLayout);
 
     void Finalize(ID3D12Device* pd3d12Device);
 
@@ -312,10 +312,10 @@ public:
 
     void InitResourceCache(class RenderDeviceD3D12Impl* pDeviceD3D12Impl, class ShaderResourceCacheD3D12& ResourceCache, IMemoryAllocator& CacheMemAllocator) const;
 
-    void InitStaticSampler(SHADER_TYPE                     ShaderType,
-                           const char*                     SamplerName,
-                           const char*                     SamplerSuffix,
-                           const D3DShaderResourceAttribs& ShaderResAttribs);
+    void InitImmutableSampler(SHADER_TYPE                     ShaderType,
+                              const char*                     SamplerName,
+                              const char*                     SamplerSuffix,
+                              const D3DShaderResourceAttribs& ShaderResAttribs);
 
     void AllocateResourceSlot(SHADER_TYPE                     ShaderType,
                               PIPELINE_TYPE                   PipelineType,
@@ -481,22 +481,22 @@ private:
 
     RootParamsManager m_RootParams;
 
-    struct StaticSamplerAttribs
+    struct ImmutableSamplerAttribs
     {
-        StaticSamplerDesc       SamplerDesc;
+        ImmutableSamplerDesc    SamplerDesc;
         UINT                    ShaderRegister   = static_cast<UINT>(-1);
         UINT                    ArraySize        = 0;
         UINT                    RegisterSpace    = 0;
         D3D12_SHADER_VISIBILITY ShaderVisibility = static_cast<D3D12_SHADER_VISIBILITY>(-1);
 
-        StaticSamplerAttribs() noexcept {}
-        StaticSamplerAttribs(const StaticSamplerDesc& SamDesc, D3D12_SHADER_VISIBILITY Visibility) noexcept :
+        ImmutableSamplerAttribs() noexcept {}
+        ImmutableSamplerAttribs(const ImmutableSamplerDesc& SamDesc, D3D12_SHADER_VISIBILITY Visibility) noexcept :
             SamplerDesc(SamDesc),
             ShaderVisibility(Visibility)
         {}
     };
-    // Note: sizeof(m_StaticSamplers) == 56 (MS compiler, release x64)
-    std::vector<StaticSamplerAttribs, STDAllocatorRawMem<StaticSamplerAttribs>> m_StaticSamplers;
+    // Note: sizeof(m_ImmutableSamplers) == 56 (MS compiler, release x64)
+    std::vector<ImmutableSamplerAttribs, STDAllocatorRawMem<ImmutableSamplerAttribs>> m_ImmutableSamplers;
 
     IMemoryAllocator& m_MemAllocator;
 
diff --git a/Graphics/GraphicsEngineD3D12/include/ShaderResourceBindingD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/ShaderResourceBindingD3D12Impl.hpp
index 846cb329..7be3372d 100644
--- a/Graphics/GraphicsEngineD3D12/include/ShaderResourceBindingD3D12Impl.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/ShaderResourceBindingD3D12Impl.hpp
@@ -78,6 +78,8 @@ public:
     }
 
 private:
+    void Destruct();
+
     ShaderResourceCacheD3D12    m_ShaderResourceCache;
     ShaderVariableManagerD3D12* m_pShaderVarMgrs = nullptr;
 
diff --git a/Graphics/GraphicsEngineD3D12/include/ShaderResourceCacheD3D12.hpp b/Graphics/GraphicsEngineD3D12/include/ShaderResourceCacheD3D12.hpp
index 1a0362ab..8a8f7b25 100644
--- a/Graphics/GraphicsEngineD3D12/include/ShaderResourceCacheD3D12.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/ShaderResourceCacheD3D12.hpp
@@ -110,7 +110,7 @@ public:
         SRBResources
     };
 
-    ShaderResourceCacheD3D12(DbgCacheContentType dbgContentType)
+    ShaderResourceCacheD3D12(DbgCacheContentType dbgContentType) noexcept
     // clang-format off
 #ifdef DILIGENT_DEBUG
         : m_DbgContentType
diff --git a/Graphics/GraphicsEngineD3D12/include/ShaderResourceLayoutD3D12.hpp b/Graphics/GraphicsEngineD3D12/include/ShaderResourceLayoutD3D12.hpp
index e043cf4a..719345fc 100644
--- a/Graphics/GraphicsEngineD3D12/include/ShaderResourceLayoutD3D12.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/ShaderResourceLayoutD3D12.hpp
@@ -112,21 +112,24 @@ namespace Diligent
 class ShaderResourceLayoutD3D12 final
 {
 public:
-    // There are two modes a layout can be constructed:
+    explicit ShaderResourceLayoutD3D12(IObject& Owner) noexcept :
+        m_Owner{Owner}
+    {}
+
+    // There are two modes a layout can be initialized:
     //  - initialize static resource layout and initialize shader resource cache to hold static resources
     //  - initialize reference layouts that address all types of resources (static, mutable, dynamic).
     //    Root indices and descriptor table offsets are assigned during the initialization;
     //    no shader resource cache is provided
-    ShaderResourceLayoutD3D12(IObject&                                    Owner,
-                              ID3D12Device*                               pd3d12Device,
-                              PIPELINE_TYPE                               PipelineType,
-                              const PipelineResourceLayoutDesc&           ResourceLayout,
-                              std::shared_ptr<const ShaderResourcesD3D12> pSrcResources,
-                              IMemoryAllocator&                           LayoutDataAllocator,
-                              const SHADER_RESOURCE_VARIABLE_TYPE* const  VarTypes,
-                              Uint32                                      NumAllowedTypes,
-                              ShaderResourceCacheD3D12*                   pResourceCache,
-                              class RootSignature*                        pRootSig);
+    void Initialize(ID3D12Device*                               pd3d12Device,
+                    PIPELINE_TYPE                               PipelineType,
+                    const PipelineResourceLayoutDesc&           ResourceLayout,
+                    std::shared_ptr<const ShaderResourcesD3D12> pSrcResources,
+                    IMemoryAllocator&                           LayoutDataAllocator,
+                    const SHADER_RESOURCE_VARIABLE_TYPE* const  VarTypes,
+                    Uint32                                      NumAllowedTypes,
+                    ShaderResourceCacheD3D12*                   pResourceCache,
+                    class RootSignature*                        pRootSig);
 
     // clang-format off
     ShaderResourceLayoutD3D12            (const ShaderResourceLayoutD3D12&) = delete;
@@ -273,6 +276,8 @@ public:
 
     SHADER_TYPE GetShaderType() const { return m_pResources->GetShaderType(); }
 
+    const ShaderResourcesD3D12& GetResources() const { return *m_pResources; }
+
 private:
     const D3D12Resource& GetAssignedSampler(const D3D12Resource& TexSrv) const;
     D3D12Resource&       GetAssignedSampler(const D3D12Resource& TexSrv);
diff --git a/Graphics/GraphicsEngineD3D12/include/ShaderVariableD3D12.hpp b/Graphics/GraphicsEngineD3D12/include/ShaderVariableD3D12.hpp
index 213748d9..c30d8296 100644
--- a/Graphics/GraphicsEngineD3D12/include/ShaderVariableD3D12.hpp
+++ b/Graphics/GraphicsEngineD3D12/include/ShaderVariableD3D12.hpp
@@ -76,12 +76,16 @@ class ShaderVariableD3D12Impl;
 class ShaderVariableManagerD3D12
 {
 public:
-    ShaderVariableManagerD3D12(IObject&                             Owner,
-                               const ShaderResourceLayoutD3D12&     Layout,
-                               IMemoryAllocator&                    Allocator,
-                               const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
-                               Uint32                               NumAllowedTypes,
-                               ShaderResourceCacheD3D12&            ResourceCache);
+    ShaderVariableManagerD3D12(IObject&                  Owner,
+                               ShaderResourceCacheD3D12& ResourceCache) noexcept :
+        m_Owner{Owner},
+        m_ResourceCache{ResourceCache}
+    {}
+
+    void Initialize(const ShaderResourceLayoutD3D12&     Layout,
+                    IMemoryAllocator&                    Allocator,
+                    const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
+                    Uint32                               NumAllowedTypes);
     ~ShaderVariableManagerD3D12();
 
     void Destroy(IMemoryAllocator& Allocator);
@@ -120,7 +124,7 @@ private:
     Uint32                           m_NumVariables = 0;
 
 #ifdef DILIGENT_DEBUG
-    IMemoryAllocator&                m_DbgAllocator;
+    IMemoryAllocator*                m_pDbgAllocator = nullptr;
 #endif
     // clang-format on
 };
diff --git a/Graphics/GraphicsEngineD3D12/src/BufferD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/BufferD3D12Impl.cpp
index c89a7423..d7cd54b6 100644
--- a/Graphics/GraphicsEngineD3D12/src/BufferD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/BufferD3D12Impl.cpp
@@ -68,8 +68,8 @@ BufferD3D12Impl::BufferD3D12Impl(IReferenceCounters*        pRefCounters,
         LOG_ERROR_AND_THROW("Unified resources are not supported in Direct3D12");
     }
 
-    if (m_Desc.Usage == USAGE_STATIC)
-        VERIFY(pBuffData != nullptr && pBuffData->pData != nullptr, "Initial data must not be null for static buffers");
+    if (m_Desc.Usage == USAGE_IMMUTABLE)
+        VERIFY(pBuffData != nullptr && pBuffData->pData != nullptr, "Initial data must not be null for immutable buffers");
     if (m_Desc.Usage == USAGE_DYNAMIC)
         VERIFY(pBuffData == nullptr || pBuffData->pData == nullptr, "Initial data must be null for dynamic buffers");
 
diff --git a/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp b/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
index c833f68e..89c495b9 100644
--- a/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
@@ -321,7 +321,7 @@ D3D12_STATIC_BORDER_COLOR BorderColorToD3D12StaticBorderColor(const Float32 Bord
         StaticBorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE;
     else
     {
-        LOG_ERROR_MESSAGE("Static samplers only allow transparent black (0,0,0,0), opaque black (0,0,0,1) or opaque white (1,1,1,1) as border colors.");
+        LOG_ERROR_MESSAGE("D3D12 static samplers only allow transparent black (0,0,0,0), opaque black (0,0,0,1) or opaque white (1,1,1,1) as border colors.");
     }
     return StaticBorderColor;
 }
diff --git a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
index af0b1113..b89b226c 100644
--- a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
@@ -211,49 +211,60 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)
         // This is necessary because if the command list had been flushed
         // and the first PSO set on the command list was a compute pipeline,
         // the states would otherwise never be committed (since m_pPipelineState != nullptr)
-        CommitStates = OldPSODesc.IsComputePipeline();
+        CommitStates = !OldPSODesc.IsAnyGraphicsPipeline();
         // We also need to update scissor rect if ScissorEnable state has changed
-        CommitScissor = OldPSODesc.GraphicsPipeline.RasterizerDesc.ScissorEnable != PSODesc.GraphicsPipeline.RasterizerDesc.ScissorEnable;
+        if (OldPSODesc.IsAnyGraphicsPipeline() && PSODesc.IsAnyGraphicsPipeline())
+            CommitScissor = m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable != pPipelineStateD3D12->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable;
     }
 
     TDeviceContextBase::SetPipelineState(pPipelineStateD3D12, 0 /*Dummy*/);
 
-    auto& CmdCtx = GetCmdContext();
-
+    auto& CmdCtx    = GetCmdContext();
     auto* pd3d12PSO = pPipelineStateD3D12->GetD3D12PipelineState();
-    if (PSODesc.IsComputePipeline())
-    {
-        CmdCtx.AsComputeContext().SetPipelineState(pd3d12PSO);
-    }
-    else
+
+    switch (PSODesc.PipelineType)
     {
-        VERIFY_EXPR(PSODesc.IsAnyGraphicsPipeline());
+        case PIPELINE_TYPE_GRAPHICS:
+        case PIPELINE_TYPE_MESH:
+        {
+            auto& GraphicsPipeline = pPipelineStateD3D12->GetGraphicsPipelineDesc();
+            auto& GraphicsCtx      = CmdCtx.AsGraphicsContext();
+            GraphicsCtx.SetPipelineState(pd3d12PSO);
 
-        auto& GraphicsCtx = CmdCtx.AsGraphicsContext();
-        GraphicsCtx.SetPipelineState(pd3d12PSO);
+            if (PSODesc.PipelineType == PIPELINE_TYPE_GRAPHICS)
+            {
+                auto D3D12Topology = TopologyToD3D12Topology(GraphicsPipeline.PrimitiveTopology);
+                GraphicsCtx.SetPrimitiveTopology(D3D12Topology);
+            }
 
-        if (PSODesc.PipelineType == PIPELINE_TYPE_GRAPHICS)
-        {
-            auto D3D12Topology = TopologyToD3D12Topology(PSODesc.GraphicsPipeline.PrimitiveTopology);
-            GraphicsCtx.SetPrimitiveTopology(D3D12Topology);
-        }
+            if (CommitStates)
+            {
+                GraphicsCtx.SetStencilRef(m_StencilRef);
+                GraphicsCtx.SetBlendFactor(m_BlendFactors);
+                if (GraphicsPipeline.pRenderPass == nullptr)
+                {
+                    CommitRenderTargets(RESOURCE_STATE_TRANSITION_MODE_VERIFY);
+                }
+                CommitViewports();
+            }
 
-        if (CommitStates)
-        {
-            GraphicsCtx.SetStencilRef(m_StencilRef);
-            GraphicsCtx.SetBlendFactor(m_BlendFactors);
-            if (PSODesc.GraphicsPipeline.pRenderPass == nullptr)
+            if (CommitStates || CommitScissor)
             {
-                CommitRenderTargets(RESOURCE_STATE_TRANSITION_MODE_VERIFY);
+                CommitScissorRects(GraphicsCtx, GraphicsPipeline.RasterizerDesc.ScissorEnable);
             }
-            CommitViewports();
+            break;
         }
 
-        if (CommitStates || CommitScissor)
+        case PIPELINE_TYPE_COMPUTE:
         {
-            CommitScissorRects(GraphicsCtx, PSODesc.GraphicsPipeline.RasterizerDesc.ScissorEnable);
+            CmdCtx.AsComputeContext().SetPipelineState(pd3d12PSO);
+            break;
         }
+
+        default:
+            UNEXPECTED("unknown pipeline type");
     }
+
     m_State.pCommittedResourceCache = nullptr;
     m_State.bRootViewsCommitted     = false;
 }
@@ -964,7 +975,7 @@ void DeviceContextD3D12Impl::SetScissorRects(Uint32 NumRects, const Rect* pRects
     if (m_pPipelineState)
     {
         const auto& PSODesc = m_pPipelineState->GetDesc();
-        if (PSODesc.IsAnyGraphicsPipeline() && PSODesc.GraphicsPipeline.RasterizerDesc.ScissorEnable)
+        if (PSODesc.IsAnyGraphicsPipeline() && m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable)
         {
             VERIFY(NumRects == m_NumScissorRects, "Unexpected number of scissor rects");
             auto& Ctx = GetCmdContext().AsGraphicsContext();
diff --git a/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
index 138b6b3d..2d31e70d 100644
--- a/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
@@ -98,155 +98,85 @@ private:
     std::array<D3D12_PRIMITIVE_TOPOLOGY_TYPE, PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES> m_Map;
 };
 
-PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pRefCounters,
-                                               RenderDeviceD3D12Impl*         pDeviceD3D12,
-                                               const PipelineStateCreateInfo& CreateInfo) :
-    TPipelineStateBase{pRefCounters, pDeviceD3D12, CreateInfo.PSODesc},
-    m_SRBMemAllocator{GetRawAllocator()}
+template <typename PSOCreateInfoType>
+void PipelineStateD3D12Impl::InitInternalObjects(const PSOCreateInfoType&                   CreateInfo,
+                                                 std::vector<D3D12PipelineShaderStageInfo>& ShaderStages)
 {
     m_ResourceLayoutIndex.fill(-1);
 
-    auto        pd3d12Device   = pDeviceD3D12->GetD3D12Device();
-    const auto& ResourceLayout = m_Desc.ResourceLayout;
-    m_RootSig.AllocateStaticSamplers(ResourceLayout);
-
-    {
-        auto& ShaderResLayoutAllocator = GetRawAllocator();
-        m_pShaderResourceLayouts       = ALLOCATE(ShaderResLayoutAllocator, "Raw memory for ShaderResourceLayoutD3D12", ShaderResourceLayoutD3D12, m_NumShaders * 2);
-    }
-
-    {
-        auto& ShaderResCacheAllocator = GetRawAllocator();
-        m_pStaticResourceCaches       = ALLOCATE(ShaderResCacheAllocator, "Raw memory for ShaderResourceCacheD3D12", ShaderResourceCacheD3D12, m_NumShaders);
-    }
-
-    {
-        auto& ShaderVarMgrAllocator = GetRawAllocator();
-        m_pStaticVarManagers        = ALLOCATE(ShaderVarMgrAllocator, "Raw memory for ShaderVariableManagerD3D12", ShaderVariableManagerD3D12, m_NumShaders);
-    }
+    ExtractShaders<ShaderD3D12Impl>(CreateInfo, ShaderStages);
 
-#ifdef DILIGENT_DEVELOPMENT
-    {
-        const ShaderResources* pResources[MAX_SHADERS_IN_PIPELINE] = {};
-        for (Uint32 s = 0; s < m_NumShaders; ++s)
-        {
-            const auto* pShader = GetShader<const ShaderD3D12Impl>(s);
-            pResources[s]       = &(*pShader->GetShaderResources());
-        }
-        ShaderResources::DvpVerifyResourceLayout(ResourceLayout, pResources, m_NumShaders,
-                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES) == 0,
-                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_STATIC_SAMPLERS) == 0);
-    }
-#endif
+    LinearAllocator MemPool{GetRawAllocator()};
 
-    for (Uint32 s = 0; s < m_NumShaders; ++s)
-    {
-        auto* pShaderD3D12 = GetShader<ShaderD3D12Impl>(s);
-        auto  ShaderType   = pShaderD3D12->GetDesc().ShaderType;
-        auto  ShaderInd    = GetShaderTypePipelineIndex(ShaderType, m_Desc.PipelineType);
+    const auto NumShaderStages = GetNumShaderStages();
+    VERIFY_EXPR(NumShaderStages > 0 && NumShaderStages == ShaderStages.size());
 
-        m_ResourceLayoutIndex[ShaderInd] = static_cast<Int8>(s);
+    MemPool.AddSpace<ShaderResourceCacheD3D12>(NumShaderStages);
+    MemPool.AddSpace<ShaderResourceLayoutD3D12>(NumShaderStages * 2);
+    MemPool.AddSpace<ShaderVariableManagerD3D12>(NumShaderStages);
 
-        new (m_pShaderResourceLayouts + s)
-            ShaderResourceLayoutD3D12 //
-            {
-                *this,
-                pDeviceD3D12->GetD3D12Device(),
-                m_Desc.PipelineType,
-                ResourceLayout,
-                pShaderD3D12->GetShaderResources(),
-                GetRawAllocator(),
-                nullptr,
-                0,
-                nullptr,
-                &m_RootSig //
-            };
+    ReserveSpaceForPipelineDesc(CreateInfo, MemPool);
 
-        new (m_pStaticResourceCaches + s) ShaderResourceCacheD3D12{ShaderResourceCacheD3D12::DbgCacheContentType::StaticShaderResources};
+    MemPool.Reserve();
 
-        const SHADER_RESOURCE_VARIABLE_TYPE StaticVarType[] = {SHADER_RESOURCE_VARIABLE_TYPE_STATIC};
-        new (m_pShaderResourceLayouts + m_NumShaders + s)
-            ShaderResourceLayoutD3D12 //
-            {
-                *this,
-                pDeviceD3D12->GetD3D12Device(),
-                m_Desc.PipelineType,
-                ResourceLayout,
-                pShaderD3D12->GetShaderResources(),
-                GetRawAllocator(),
-                StaticVarType,
-                _countof(StaticVarType),
-                m_pStaticResourceCaches + s,
-                nullptr //
-            };
+    m_pStaticResourceCaches = MemPool.ConstructArray<ShaderResourceCacheD3D12>(NumShaderStages, ShaderResourceCacheD3D12::DbgCacheContentType::StaticShaderResources);
 
-        new (m_pStaticVarManagers + s)
-            ShaderVariableManagerD3D12 //
-            {
-                *this,
-                GetStaticShaderResLayout(s),
-                GetRawAllocator(),
-                nullptr,
-                0,
-                GetStaticShaderResCache(s) //
-            };
-    }
-    m_RootSig.Finalize(pd3d12Device);
+    // The memory is now owned by PipelineStateD3D12Impl and will be freed by Destruct().
+    auto* Ptr = MemPool.ReleaseOwnership();
+    VERIFY_EXPR(Ptr == m_pStaticResourceCaches);
+    (void)Ptr;
 
-    switch (m_Desc.PipelineType)
-    {
-        case PIPELINE_TYPE_COMPUTE:
-        {
-            auto& ComputePipeline = m_Desc.ComputePipeline;
+    m_pShaderResourceLayouts = MemPool.ConstructArray<ShaderResourceLayoutD3D12>(NumShaderStages * 2, std::ref(*this));
 
-            if (ComputePipeline.pCS == nullptr)
-                LOG_ERROR_AND_THROW("Compute shader is not set in the pipeline desc");
+    m_pStaticVarManagers = MemPool.Allocate<ShaderVariableManagerD3D12>(NumShaderStages);
+    for (Uint32 s = 0; s < NumShaderStages; ++s)
+        new (m_pStaticVarManagers + s) ShaderVariableManagerD3D12{*this, GetStaticShaderResCache(s)};
 
-            D3D12_COMPUTE_PIPELINE_STATE_DESC d3d12PSODesc = {};
+    InitializePipelineDesc(CreateInfo, MemPool);
 
-            auto* pByteCode                 = ValidatedCast<ShaderD3D12Impl>(ComputePipeline.pCS)->GetShaderByteCode();
-            d3d12PSODesc.CS.pShaderBytecode = pByteCode->GetBufferPointer();
-            d3d12PSODesc.CS.BytecodeLength  = pByteCode->GetBufferSize();
+    m_RootSig.AllocateImmutableSamplers(CreateInfo.PSODesc.ResourceLayout);
 
-            // For single GPU operation, set this to zero. If there are multiple GPU nodes,
-            // set bits to identify the nodes (the device's physical adapters) for which the
-            // graphics pipeline state is to apply. Each bit in the mask corresponds to a single node.
-            d3d12PSODesc.NodeMask = 0;
+    // It is important to construct all objects before initializing them because if an exception is thrown,
+    // destructors will be called for all objects
 
-            d3d12PSODesc.CachedPSO.pCachedBlob           = nullptr;
-            d3d12PSODesc.CachedPSO.CachedBlobSizeInBytes = 0;
+    InitResourceLayouts(CreateInfo, ShaderStages);
+}
 
-            // The only valid bit is D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG, which can only be set on WARP devices.
-            d3d12PSODesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
 
-            d3d12PSODesc.pRootSignature = m_RootSig.GetD3D12RootSignature();
+PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*                    pRefCounters,
+                                               RenderDeviceD3D12Impl*                 pDeviceD3D12,
+                                               const GraphicsPipelineStateCreateInfo& CreateInfo) :
+    TPipelineStateBase{pRefCounters, pDeviceD3D12, CreateInfo.PSODesc},
+    m_SRBMemAllocator{GetRawAllocator()}
+{
+    try
+    {
+        std::vector<D3D12PipelineShaderStageInfo> ShaderStages;
 
-            HRESULT hr = pd3d12Device->CreateComputePipelineState(&d3d12PSODesc, __uuidof(ID3D12PipelineState), reinterpret_cast<void**>(static_cast<ID3D12PipelineState**>(&m_pd3d12PSO)));
-            if (FAILED(hr))
-                LOG_ERROR_AND_THROW("Failed to create pipeline state");
-            break;
-        }
+        InitInternalObjects(CreateInfo, ShaderStages);
 
-        case PIPELINE_TYPE_GRAPHICS:
+        auto pd3d12Device = pDeviceD3D12->GetD3D12Device();
+        if (m_Desc.PipelineType == PIPELINE_TYPE_GRAPHICS)
         {
-            const auto& GraphicsPipeline = m_Desc.GraphicsPipeline;
+            const auto& GraphicsPipeline = GetGraphicsPipelineDesc();
 
             D3D12_GRAPHICS_PIPELINE_STATE_DESC d3d12PSODesc = {};
 
-            for (Uint32 s = 0; s < m_NumShaders; ++s)
+            for (const auto& Stage : ShaderStages)
             {
-                auto* pShaderD3D12 = GetShader<ShaderD3D12Impl>(s);
+                auto* pShaderD3D12 = Stage.pShader;
                 auto  ShaderType   = pShaderD3D12->GetDesc().ShaderType;
+                VERIFY_EXPR(ShaderType == Stage.Type);
 
                 D3D12_SHADER_BYTECODE* pd3d12ShaderBytecode = nullptr;
                 switch (ShaderType)
                 {
-                    // clang-format off
-                    case SHADER_TYPE_VERTEX:   pd3d12ShaderBytecode = &d3d12PSODesc.VS; break;
-                    case SHADER_TYPE_PIXEL:    pd3d12ShaderBytecode = &d3d12PSODesc.PS; break;
-                    case SHADER_TYPE_GEOMETRY: pd3d12ShaderBytecode = &d3d12PSODesc.GS; break;
-                    case SHADER_TYPE_HULL:     pd3d12ShaderBytecode = &d3d12PSODesc.HS; break;
-                    case SHADER_TYPE_DOMAIN:   pd3d12ShaderBytecode = &d3d12PSODesc.DS; break;
+                        // clang-format off
+                case SHADER_TYPE_VERTEX:   pd3d12ShaderBytecode = &d3d12PSODesc.VS; break;
+                case SHADER_TYPE_PIXEL:    pd3d12ShaderBytecode = &d3d12PSODesc.PS; break;
+                case SHADER_TYPE_GEOMETRY: pd3d12ShaderBytecode = &d3d12PSODesc.GS; break;
+                case SHADER_TYPE_HULL:     pd3d12ShaderBytecode = &d3d12PSODesc.HS; break;
+                case SHADER_TYPE_DOMAIN:   pd3d12ShaderBytecode = &d3d12PSODesc.DS; break;
                     // clang-format on
                     default: UNEXPECTED("Unexpected shader type");
                 }
@@ -269,7 +199,7 @@ PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pR
 
             std::vector<D3D12_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D12_INPUT_ELEMENT_DESC>> d312InputElements(STD_ALLOCATOR_RAW_MEM(D3D12_INPUT_ELEMENT_DESC, GetRawAllocator(), "Allocator for vector<D3D12_INPUT_ELEMENT_DESC>"));
 
-            const auto& InputLayout = m_Desc.GraphicsPipeline.InputLayout;
+            const auto& InputLayout = GetGraphicsPipelineDesc().InputLayout;
             if (InputLayout.NumElements > 0)
             {
                 LayoutElements_To_D3D12_INPUT_ELEMENT_DESCs(InputLayout, d312InputElements);
@@ -310,13 +240,12 @@ PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pR
             HRESULT hr = pd3d12Device->CreateGraphicsPipelineState(&d3d12PSODesc, __uuidof(ID3D12PipelineState), reinterpret_cast<void**>(static_cast<ID3D12PipelineState**>(&m_pd3d12PSO)));
             if (FAILED(hr))
                 LOG_ERROR_AND_THROW("Failed to create pipeline state");
-            break;
         }
 
 #ifdef D3D12_H_HAS_MESH_SHADER
-        case PIPELINE_TYPE_MESH:
+        else if (m_Desc.PipelineType == PIPELINE_TYPE_MESH)
         {
-            const auto& GraphicsPipeline = m_Desc.GraphicsPipeline;
+            const auto& GraphicsPipeline = GetGraphicsPipelineDesc();
 
             struct MESH_SHADER_PIPELINE_STATE_DESC
             {
@@ -337,18 +266,19 @@ PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pR
             };
             MESH_SHADER_PIPELINE_STATE_DESC d3d12PSODesc = {};
 
-            for (Uint32 s = 0; s < m_NumShaders; ++s)
+            for (const auto& Stage : ShaderStages)
             {
-                auto* pShaderD3D12 = GetShader<ShaderD3D12Impl>(s);
+                auto* pShaderD3D12 = Stage.pShader;
                 auto  ShaderType   = pShaderD3D12->GetDesc().ShaderType;
+                VERIFY_EXPR(ShaderType == Stage.Type);
 
                 D3D12_SHADER_BYTECODE* pd3d12ShaderBytecode = nullptr;
                 switch (ShaderType)
                 {
-                    // clang-format off
-                    case SHADER_TYPE_AMPLIFICATION: pd3d12ShaderBytecode = &d3d12PSODesc.AS; break;
-                    case SHADER_TYPE_MESH:          pd3d12ShaderBytecode = &d3d12PSODesc.MS; break;
-                    case SHADER_TYPE_PIXEL:         pd3d12ShaderBytecode = &d3d12PSODesc.PS; break;
+                        // clang-format off
+                case SHADER_TYPE_AMPLIFICATION: pd3d12ShaderBytecode = &d3d12PSODesc.AS; break;
+                case SHADER_TYPE_MESH:          pd3d12ShaderBytecode = &d3d12PSODesc.MS; break;
+                case SHADER_TYPE_PIXEL:         pd3d12ShaderBytecode = &d3d12PSODesc.PS; break;
                     // clang-format on
                     default: UNEXPECTED("Unexpected shader type");
                 }
@@ -394,27 +324,192 @@ PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pR
             auto* device2 = pDeviceD3D12->GetD3D12Device2();
 
             CHECK_D3D_RESULT_THROW(device2->CreatePipelineState(&streamDesc, IID_PPV_ARGS(&m_pd3d12PSO)), "Failed to create pipeline state");
-            break;
         }
 #endif // D3D12_H_HAS_MESH_SHADER
-
-        default:
+        else
+        {
             LOG_ERROR_AND_THROW("Unsupported pipeline type");
+        }
+
+        if (*m_Desc.Name != 0)
+        {
+            m_pd3d12PSO->SetName(WidenString(m_Desc.Name).c_str());
+            String RootSignatureDesc("Root signature for PSO '");
+            RootSignatureDesc.append(m_Desc.Name);
+            RootSignatureDesc.push_back('\'');
+            m_RootSig.GetD3D12RootSignature()->SetName(WidenString(RootSignatureDesc).c_str());
+        }
+    }
+    catch (...)
+    {
+        Destruct();
+        throw;
     }
+}
 
-    if (*m_Desc.Name != 0)
+PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*                   pRefCounters,
+                                               RenderDeviceD3D12Impl*                pDeviceD3D12,
+                                               const ComputePipelineStateCreateInfo& CreateInfo) :
+    TPipelineStateBase{pRefCounters, pDeviceD3D12, CreateInfo.PSODesc},
+    m_SRBMemAllocator{GetRawAllocator()}
+{
+    try
     {
-        m_pd3d12PSO->SetName(WidenString(m_Desc.Name).c_str());
-        String RootSignatureDesc("Root signature for PSO '");
-        RootSignatureDesc.append(m_Desc.Name);
-        RootSignatureDesc.push_back('\'');
-        m_RootSig.GetD3D12RootSignature()->SetName(WidenString(RootSignatureDesc).c_str());
+        std::vector<D3D12PipelineShaderStageInfo> ShaderStages;
+
+        InitInternalObjects(CreateInfo, ShaderStages);
+
+        auto pd3d12Device = pDeviceD3D12->GetD3D12Device();
+
+        D3D12_COMPUTE_PIPELINE_STATE_DESC d3d12PSODesc = {};
+
+        VERIFY_EXPR(ShaderStages[0].Type == SHADER_TYPE_COMPUTE);
+        auto* pByteCode                 = ShaderStages[0].pShader->GetShaderByteCode();
+        d3d12PSODesc.CS.pShaderBytecode = pByteCode->GetBufferPointer();
+        d3d12PSODesc.CS.BytecodeLength  = pByteCode->GetBufferSize();
+
+        // For single GPU operation, set this to zero. If there are multiple GPU nodes,
+        // set bits to identify the nodes (the device's physical adapters) for which the
+        // graphics pipeline state is to apply. Each bit in the mask corresponds to a single node.
+        d3d12PSODesc.NodeMask = 0;
+
+        d3d12PSODesc.CachedPSO.pCachedBlob           = nullptr;
+        d3d12PSODesc.CachedPSO.CachedBlobSizeInBytes = 0;
+
+        // The only valid bit is D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG, which can only be set on WARP devices.
+        d3d12PSODesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
+
+        d3d12PSODesc.pRootSignature = m_RootSig.GetD3D12RootSignature();
+
+        HRESULT hr = pd3d12Device->CreateComputePipelineState(&d3d12PSODesc, __uuidof(ID3D12PipelineState), reinterpret_cast<void**>(static_cast<ID3D12PipelineState**>(&m_pd3d12PSO)));
+        if (FAILED(hr))
+            LOG_ERROR_AND_THROW("Failed to create pipeline state");
+
+        if (*m_Desc.Name != 0)
+        {
+            m_pd3d12PSO->SetName(WidenString(m_Desc.Name).c_str());
+            String RootSignatureDesc("Root signature for PSO '");
+            RootSignatureDesc.append(m_Desc.Name);
+            RootSignatureDesc.push_back('\'');
+            m_RootSig.GetD3D12RootSignature()->SetName(WidenString(RootSignatureDesc).c_str());
+        }
+    }
+    catch (...)
+    {
+        Destruct();
+        throw;
+    }
+}
+
+PipelineStateD3D12Impl::~PipelineStateD3D12Impl()
+{
+    Destruct();
+}
+
+void PipelineStateD3D12Impl::Destruct()
+{
+    auto& ShaderResLayoutAllocator = GetRawAllocator();
+    for (Uint32 s = 0; s < GetNumShaderStages(); ++s)
+    {
+        if (m_pStaticVarManagers != nullptr)
+        {
+            m_pStaticVarManagers[s].Destroy(GetRawAllocator());
+            m_pStaticVarManagers[s].~ShaderVariableManagerD3D12();
+        }
+
+        if (m_pShaderResourceLayouts != nullptr)
+        {
+            m_pShaderResourceLayouts[s].~ShaderResourceLayoutD3D12();
+            m_pShaderResourceLayouts[GetNumShaderStages() + s].~ShaderResourceLayoutD3D12();
+        }
+
+        if (m_pStaticResourceCaches != nullptr)
+        {
+            m_pStaticResourceCaches[s].~ShaderResourceCacheD3D12();
+        }
+    }
+    // All internal objects are allocated in contiguous chunks of memory.
+    if (auto* pRawMem = m_pStaticResourceCaches)
+    {
+        ShaderResLayoutAllocator.Free(pRawMem);
     }
 
+    if (m_pd3d12PSO)
+    {
+        // D3D12 object can only be destroyed when it is no longer used by the GPU
+        m_pDevice->SafeReleaseDeviceObject(std::move(m_pd3d12PSO), m_Desc.CommandQueueMask);
+    }
+}
+
+IMPLEMENT_QUERY_INTERFACE(PipelineStateD3D12Impl, IID_PipelineStateD3D12, TPipelineStateBase)
+
+
+void PipelineStateD3D12Impl::InitResourceLayouts(const PipelineStateCreateInfo&             CreateInfo,
+                                                 std::vector<D3D12PipelineShaderStageInfo>& ShaderStages)
+{
+    auto        pd3d12Device   = GetDevice()->GetD3D12Device();
+    const auto& ResourceLayout = m_Desc.ResourceLayout;
+
+#ifdef DILIGENT_DEVELOPMENT
+    {
+        const ShaderResources* pResources[MAX_SHADERS_IN_PIPELINE] = {};
+        for (size_t s = 0; s < ShaderStages.size(); ++s)
+        {
+            const auto* pShader = ShaderStages[s].pShader;
+            pResources[s]       = &(*pShader->GetShaderResources());
+        }
+        ShaderResources::DvpVerifyResourceLayout(ResourceLayout, pResources, GetNumShaderStages(),
+                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES) == 0,
+                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_IMMUTABLE_SAMPLERS) == 0);
+    }
+#endif
+
+    for (size_t s = 0; s < ShaderStages.size(); ++s)
+    {
+        auto* pShaderD3D12 = ShaderStages[s].pShader;
+        auto  ShaderType   = pShaderD3D12->GetDesc().ShaderType;
+        auto  ShaderInd    = GetShaderTypePipelineIndex(ShaderType, m_Desc.PipelineType);
+
+        m_ResourceLayoutIndex[ShaderInd] = static_cast<Int8>(s);
+
+        m_pShaderResourceLayouts[s].Initialize(
+            pd3d12Device,
+            m_Desc.PipelineType,
+            ResourceLayout,
+            pShaderD3D12->GetShaderResources(),
+            GetRawAllocator(),
+            nullptr,
+            0,
+            nullptr,
+            &m_RootSig //
+        );
+
+        const SHADER_RESOURCE_VARIABLE_TYPE StaticVarType[] = {SHADER_RESOURCE_VARIABLE_TYPE_STATIC};
+        m_pShaderResourceLayouts[GetNumShaderStages() + s].Initialize(
+            pd3d12Device,
+            m_Desc.PipelineType,
+            ResourceLayout,
+            pShaderD3D12->GetShaderResources(),
+            GetRawAllocator(),
+            StaticVarType,
+            _countof(StaticVarType),
+            m_pStaticResourceCaches + s,
+            nullptr //
+        );
+
+        m_pStaticVarManagers[s].Initialize(
+            GetStaticShaderResLayout(static_cast<Uint32>(s)),
+            GetRawAllocator(),
+            nullptr,
+            0 //
+        );
+    }
+    m_RootSig.Finalize(pd3d12Device);
+
     if (m_Desc.SRBAllocationGranularity > 1)
     {
         std::array<size_t, MAX_SHADERS_IN_PIPELINE> ShaderVarMgrDataSizes = {};
-        for (Uint32 s = 0; s < m_NumShaders; ++s)
+        for (Uint32 s = 0; s < GetNumShaderStages(); ++s)
         {
             std::array<SHADER_RESOURCE_VARIABLE_TYPE, 2> AllowedVarTypes =
                 {
@@ -427,34 +522,12 @@ PipelineStateD3D12Impl::PipelineStateD3D12Impl(IReferenceCounters*            pR
         }
 
         auto CacheMemorySize = m_RootSig.GetResourceCacheRequiredMemSize();
-        m_SRBMemAllocator.Initialize(m_Desc.SRBAllocationGranularity, m_NumShaders, ShaderVarMgrDataSizes.data(), 1, &CacheMemorySize);
+        m_SRBMemAllocator.Initialize(m_Desc.SRBAllocationGranularity, GetNumShaderStages(), ShaderVarMgrDataSizes.data(), 1, &CacheMemorySize);
     }
 
     m_ShaderResourceLayoutHash = m_RootSig.GetHash();
 }
 
-PipelineStateD3D12Impl::~PipelineStateD3D12Impl()
-{
-    auto& ShaderResLayoutAllocator = GetRawAllocator();
-    for (Uint32 s = 0; s < m_NumShaders; ++s)
-    {
-        m_pStaticVarManagers[s].Destroy(GetRawAllocator());
-        m_pStaticVarManagers[s].~ShaderVariableManagerD3D12();
-        m_pStaticResourceCaches[s].~ShaderResourceCacheD3D12();
-        m_pShaderResourceLayouts[s].~ShaderResourceLayoutD3D12();
-        m_pShaderResourceLayouts[m_NumShaders + s].~ShaderResourceLayoutD3D12();
-    }
-    ShaderResLayoutAllocator.Free(m_pStaticVarManagers);
-    ShaderResLayoutAllocator.Free(m_pStaticResourceCaches);
-    ShaderResLayoutAllocator.Free(m_pShaderResourceLayouts);
-
-    // D3D12 object can only be destroyed when it is no longer used by the GPU
-    m_pDevice->SafeReleaseDeviceObject(std::move(m_pd3d12PSO), m_Desc.CommandQueueMask);
-}
-
-IMPLEMENT_QUERY_INTERFACE(PipelineStateD3D12Impl, IID_PipelineStateD3D12, TPipelineStateBase)
-
-
 void PipelineStateD3D12Impl::CreateShaderResourceBinding(IShaderResourceBinding** ppShaderResourceBinding, bool InitStaticResources)
 {
     auto& SRBAllocator     = m_pDevice->GetSRBAllocator();
@@ -480,23 +553,22 @@ bool PipelineStateD3D12Impl::IsCompatibleWith(const IPipelineState* pPSO) const
 #ifdef DILIGENT_DEBUG
     {
         bool IsCompatibleShaders = true;
-        if (m_NumShaders != pPSOD3D12->m_NumShaders)
+        if (GetNumShaderStages() != pPSOD3D12->GetNumShaderStages())
             IsCompatibleShaders = false;
 
         if (IsCompatibleShaders)
         {
-            for (Uint32 s = 0; s < m_NumShaders; ++s)
+            for (Uint32 s = 0; s < GetNumShaderStages(); ++s)
             {
-                auto* pShader0 = GetShader<const ShaderD3D12Impl>(s);
-                auto* pShader1 = pPSOD3D12->GetShader<const ShaderD3D12Impl>(s);
-                if (pShader0->GetDesc().ShaderType != pShader1->GetDesc().ShaderType)
+                if (GetShaderStageType(s) != pPSOD3D12->GetShaderStageType(s))
                 {
                     IsCompatibleShaders = false;
                     break;
                 }
-                const ShaderResourcesD3D12* pRes0 = pShader0->GetShaderResources().get();
-                const ShaderResourcesD3D12* pRes1 = pShader1->GetShaderResources().get();
-                if (!pRes0->IsCompatibleWith(*pRes1))
+
+                const auto& Res0 = GetShaderResLayout(s).GetResources();
+                const auto& Res1 = pPSOD3D12->GetShaderResLayout(s).GetResources();
+                if (!Res0.IsCompatibleWith(Res1))
                 {
                     IsCompatibleShaders = false;
                     break;
@@ -607,7 +679,7 @@ bool PipelineStateD3D12Impl::ContainsShaderResources() const
 
 void PipelineStateD3D12Impl::BindStaticResources(Uint32 ShaderFlags, IResourceMapping* pResourceMapping, Uint32 Flags)
 {
-    for (Uint32 s = 0; s < m_NumShaders; ++s)
+    for (Uint32 s = 0; s < GetNumShaderStages(); ++s)
     {
         auto ShaderType = GetStaticShaderResLayout(s).GetShaderType();
         if ((ShaderFlags & ShaderType) != 0)
@@ -621,7 +693,7 @@ Uint32 PipelineStateD3D12Impl::GetStaticVariableCount(SHADER_TYPE ShaderType) co
     if (LayoutInd < 0)
         return 0;
 
-    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < m_NumShaders);
+    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < GetNumShaderStages());
     return m_pStaticVarManagers[LayoutInd].GetVariableCount();
 }
 
@@ -631,7 +703,7 @@ IShaderResourceVariable* PipelineStateD3D12Impl::GetStaticVariableByName(SHADER_
     if (LayoutInd < 0)
         return nullptr;
 
-    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < m_NumShaders);
+    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < GetNumShaderStages());
     return m_pStaticVarManagers[LayoutInd].GetVariable(Name);
 }
 
@@ -641,7 +713,7 @@ IShaderResourceVariable* PipelineStateD3D12Impl::GetStaticVariableByIndex(SHADER
     if (LayoutInd < 0)
         return nullptr;
 
-    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < m_NumShaders);
+    VERIFY_EXPR(static_cast<Uint32>(LayoutInd) < GetNumShaderStages());
     return m_pStaticVarManagers[LayoutInd].GetVariable(Index);
 }
 
diff --git a/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp
index 6e4b828e..61ad5871 100644
--- a/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp
@@ -298,7 +298,7 @@ RenderDeviceD3D12Impl::RenderDeviceD3D12Impl(IReferenceCounters*          pRefCo
 #undef CHECK_REQUIRED_FEATURE
 
 #if defined(_MSC_VER) && defined(_WIN64)
-        static_assert(sizeof(DeviceFeatures) == 31, "Did you add a new feature to DeviceFeatures? Please handle its satus here.");
+        static_assert(sizeof(DeviceFeatures) == 32, "Did you add a new feature to DeviceFeatures? Please handle its satus here.");
 #endif
 
         auto& TexCaps = m_DeviceCaps.TexCaps;
@@ -535,23 +535,35 @@ void RenderDeviceD3D12Impl::TestTextureFormat(TEXTURE_FORMAT TexFormat)
 
 IMPLEMENT_QUERY_INTERFACE(RenderDeviceD3D12Impl, IID_RenderDeviceD3D12, TRenderDeviceBase)
 
-void RenderDeviceD3D12Impl::CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+template <typename PSOCreateInfoType>
+void RenderDeviceD3D12Impl::CreatePipelineState(const PSOCreateInfoType& PSOCreateInfo, IPipelineState** ppPipelineState)
 {
     CreateDeviceObject("Pipeline State", PSOCreateInfo.PSODesc, ppPipelineState,
                        [&]() //
                        {
-                           PipelineStateD3D12Impl* pPipelineStateD3D12(NEW_RC_OBJ(m_PSOAllocator, "PipelineStateD3D12Impl instance", PipelineStateD3D12Impl)(this, PSOCreateInfo));
+                           PipelineStateD3D12Impl* pPipelineStateD3D12{NEW_RC_OBJ(m_PSOAllocator, "PipelineStateD3D12Impl instance", PipelineStateD3D12Impl)(this, PSOCreateInfo)};
                            pPipelineStateD3D12->QueryInterface(IID_PipelineState, reinterpret_cast<IObject**>(ppPipelineState));
                            OnCreateDeviceObject(pPipelineStateD3D12);
                        });
 }
 
+
+void RenderDeviceD3D12Impl::CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+{
+    CreatePipelineState(PSOCreateInfo, ppPipelineState);
+}
+
+void RenderDeviceD3D12Impl::CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+{
+    CreatePipelineState(PSOCreateInfo, ppPipelineState);
+}
+
 void RenderDeviceD3D12Impl::CreateBufferFromD3DResource(ID3D12Resource* pd3d12Buffer, const BufferDesc& BuffDesc, RESOURCE_STATE InitialState, IBuffer** ppBuffer)
 {
     CreateDeviceObject("buffer", BuffDesc, ppBuffer,
                        [&]() //
                        {
-                           BufferD3D12Impl* pBufferD3D12(NEW_RC_OBJ(m_BufObjAllocator, "BufferD3D12Impl instance", BufferD3D12Impl)(m_BuffViewObjAllocator, this, BuffDesc, InitialState, pd3d12Buffer));
+                           BufferD3D12Impl* pBufferD3D12{NEW_RC_OBJ(m_BufObjAllocator, "BufferD3D12Impl instance", BufferD3D12Impl)(m_BuffViewObjAllocator, this, BuffDesc, InitialState, pd3d12Buffer)};
                            pBufferD3D12->QueryInterface(IID_Buffer, reinterpret_cast<IObject**>(ppBuffer));
                            pBufferD3D12->CreateDefaultViews();
                            OnCreateDeviceObject(pBufferD3D12);
@@ -563,7 +575,7 @@ void RenderDeviceD3D12Impl::CreateBuffer(const BufferDesc& BuffDesc, const Buffe
     CreateDeviceObject("buffer", BuffDesc, ppBuffer,
                        [&]() //
                        {
-                           BufferD3D12Impl* pBufferD3D12(NEW_RC_OBJ(m_BufObjAllocator, "BufferD3D12Impl instance", BufferD3D12Impl)(m_BuffViewObjAllocator, this, BuffDesc, pBuffData));
+                           BufferD3D12Impl* pBufferD3D12{NEW_RC_OBJ(m_BufObjAllocator, "BufferD3D12Impl instance", BufferD3D12Impl)(m_BuffViewObjAllocator, this, BuffDesc, pBuffData)};
                            pBufferD3D12->QueryInterface(IID_Buffer, reinterpret_cast<IObject**>(ppBuffer));
                            pBufferD3D12->CreateDefaultViews();
                            OnCreateDeviceObject(pBufferD3D12);
@@ -576,7 +588,7 @@ void RenderDeviceD3D12Impl::CreateShader(const ShaderCreateInfo& ShaderCI, IShad
     CreateDeviceObject("shader", ShaderCI.Desc, ppShader,
                        [&]() //
                        {
-                           ShaderD3D12Impl* pShaderD3D12(NEW_RC_OBJ(m_ShaderObjAllocator, "ShaderD3D12Impl instance", ShaderD3D12Impl)(this, ShaderCI));
+                           ShaderD3D12Impl* pShaderD3D12{NEW_RC_OBJ(m_ShaderObjAllocator, "ShaderD3D12Impl instance", ShaderD3D12Impl)(this, ShaderCI)};
                            pShaderD3D12->QueryInterface(IID_Shader, reinterpret_cast<IObject**>(ppShader));
 
                            OnCreateDeviceObject(pShaderD3D12);
@@ -590,7 +602,7 @@ void RenderDeviceD3D12Impl::CreateTextureFromD3DResource(ID3D12Resource* pd3d12T
     CreateDeviceObject("texture", TexDesc, ppTexture,
                        [&]() //
                        {
-                           TextureD3D12Impl* pTextureD3D12 = NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, InitialState, pd3d12Texture);
+                           TextureD3D12Impl* pTextureD3D12{NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, InitialState, pd3d12Texture)};
 
                            pTextureD3D12->QueryInterface(IID_Texture, reinterpret_cast<IObject**>(ppTexture));
                            pTextureD3D12->CreateDefaultViews();
@@ -603,7 +615,7 @@ void RenderDeviceD3D12Impl::CreateTexture(const TextureDesc& TexDesc, ID3D12Reso
     CreateDeviceObject("texture", TexDesc, ppTexture,
                        [&]() //
                        {
-                           TextureD3D12Impl* pTextureD3D12 = NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, InitialState, pd3d12Texture);
+                           TextureD3D12Impl* pTextureD3D12{NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, InitialState, pd3d12Texture)};
                            pTextureD3D12->QueryInterface(IID_TextureD3D12, reinterpret_cast<IObject**>(ppTexture));
                        });
 }
@@ -613,7 +625,7 @@ void RenderDeviceD3D12Impl::CreateTexture(const TextureDesc& TexDesc, const Text
     CreateDeviceObject("texture", TexDesc, ppTexture,
                        [&]() //
                        {
-                           TextureD3D12Impl* pTextureD3D12 = NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, pData);
+                           TextureD3D12Impl* pTextureD3D12{NEW_RC_OBJ(m_TexObjAllocator, "TextureD3D12Impl instance", TextureD3D12Impl)(m_TexViewObjAllocator, this, TexDesc, pData)};
 
                            pTextureD3D12->QueryInterface(IID_Texture, reinterpret_cast<IObject**>(ppTexture));
                            pTextureD3D12->CreateDefaultViews();
@@ -629,7 +641,7 @@ void RenderDeviceD3D12Impl::CreateSampler(const SamplerDesc& SamplerDesc, ISampl
                            m_SamplersRegistry.Find(SamplerDesc, reinterpret_cast<IDeviceObject**>(ppSampler));
                            if (*ppSampler == nullptr)
                            {
-                               SamplerD3D12Impl* pSamplerD3D12(NEW_RC_OBJ(m_SamplerObjAllocator, "SamplerD3D12Impl instance", SamplerD3D12Impl)(this, SamplerDesc));
+                               SamplerD3D12Impl* pSamplerD3D12{NEW_RC_OBJ(m_SamplerObjAllocator, "SamplerD3D12Impl instance", SamplerD3D12Impl)(this, SamplerDesc)};
                                pSamplerD3D12->QueryInterface(IID_Sampler, reinterpret_cast<IObject**>(ppSampler));
                                OnCreateDeviceObject(pSamplerD3D12);
                                m_SamplersRegistry.Add(SamplerDesc, *ppSampler);
@@ -642,7 +654,7 @@ void RenderDeviceD3D12Impl::CreateFence(const FenceDesc& Desc, IFence** ppFence)
     CreateDeviceObject("Fence", Desc, ppFence,
                        [&]() //
                        {
-                           FenceD3D12Impl* pFenceD3D12(NEW_RC_OBJ(m_FenceAllocator, "FenceD3D12Impl instance", FenceD3D12Impl)(this, Desc));
+                           FenceD3D12Impl* pFenceD3D12{NEW_RC_OBJ(m_FenceAllocator, "FenceD3D12Impl instance", FenceD3D12Impl)(this, Desc)};
                            pFenceD3D12->QueryInterface(IID_Fence, reinterpret_cast<IObject**>(ppFence));
                            OnCreateDeviceObject(pFenceD3D12);
                        });
@@ -653,7 +665,7 @@ void RenderDeviceD3D12Impl::CreateQuery(const QueryDesc& Desc, IQuery** ppQuery)
     CreateDeviceObject("Query", Desc, ppQuery,
                        [&]() //
                        {
-                           QueryD3D12Impl* pQueryD3D12(NEW_RC_OBJ(m_QueryAllocator, "QueryD3D12Impl instance", QueryD3D12Impl)(this, Desc));
+                           QueryD3D12Impl* pQueryD3D12{NEW_RC_OBJ(m_QueryAllocator, "QueryD3D12Impl instance", QueryD3D12Impl)(this, Desc)};
                            pQueryD3D12->QueryInterface(IID_Query, reinterpret_cast<IObject**>(ppQuery));
                            OnCreateDeviceObject(pQueryD3D12);
                        });
@@ -664,7 +676,7 @@ void RenderDeviceD3D12Impl::CreateRenderPass(const RenderPassDesc& Desc, IRender
     CreateDeviceObject("RenderPass", Desc, ppRenderPass,
                        [&]() //
                        {
-                           RenderPassD3D12Impl* pRenderPassD3D12(NEW_RC_OBJ(m_RenderPassAllocator, "RenderPassD3D12Impl instance", RenderPassD3D12Impl)(this, Desc));
+                           RenderPassD3D12Impl* pRenderPassD3D12{NEW_RC_OBJ(m_RenderPassAllocator, "RenderPassD3D12Impl instance", RenderPassD3D12Impl)(this, Desc)};
                            pRenderPassD3D12->QueryInterface(IID_RenderPass, reinterpret_cast<IObject**>(ppRenderPass));
                            OnCreateDeviceObject(pRenderPassD3D12);
                        });
@@ -675,7 +687,7 @@ void RenderDeviceD3D12Impl::CreateFramebuffer(const FramebufferDesc& Desc, IFram
     CreateDeviceObject("Framebuffer", Desc, ppFramebuffer,
                        [&]() //
                        {
-                           FramebufferD3D12Impl* pFramebufferD3D12(NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferD3D12Impl instance", FramebufferD3D12Impl)(this, Desc));
+                           FramebufferD3D12Impl* pFramebufferD3D12{NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferD3D12Impl instance", FramebufferD3D12Impl)(this, Desc)};
                            pFramebufferD3D12->QueryInterface(IID_Framebuffer, reinterpret_cast<IObject**>(ppFramebuffer));
                            OnCreateDeviceObject(pFramebufferD3D12);
                        });
diff --git a/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp b/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp
index bba639f8..2afb9eb1 100644
--- a/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp
@@ -166,7 +166,7 @@ size_t RootSignature::RootParamsManager::GetHash() const
 RootSignature::RootSignature() :
     m_RootParams{GetRawAllocator()},
     m_MemAllocator{GetRawAllocator()},
-    m_StaticSamplers(STD_ALLOCATOR_RAW_MEM(StaticSamplerAttribs, GetRawAllocator(), "Allocator for vector<StaticSamplerAttribs>"))
+    m_ImmutableSamplers(STD_ALLOCATOR_RAW_MEM(ImmutableSamplerAttribs, GetRawAllocator(), "Allocator for vector<ImmutableSamplerAttribs>"))
 {
     m_SrvCbvUavRootTablesMap.fill(InvalidRootTableIndex);
     m_SamplerRootTablesMap.fill(InvalidRootTableIndex);
@@ -282,29 +282,30 @@ D3D12_DESCRIPTOR_HEAP_TYPE HeapTypeFromRangeType(D3D12_DESCRIPTOR_RANGE_TYPE Ran
 }
 
 
-void RootSignature::InitStaticSampler(SHADER_TYPE                     ShaderType,
-                                      const char*                     SamplerName,
-                                      const char*                     SamplerSuffix,
-                                      const D3DShaderResourceAttribs& SamplerAttribs)
+void RootSignature::InitImmutableSampler(SHADER_TYPE                     ShaderType,
+                                         const char*                     SamplerName,
+                                         const char*                     SamplerSuffix,
+                                         const D3DShaderResourceAttribs& SamplerAttribs)
 {
     auto ShaderVisibility = GetShaderVisibility(ShaderType);
     auto SamplerFound     = false;
-    for (auto& StSmplr : m_StaticSamplers)
+    for (auto& ImtblSmplr : m_ImmutableSamplers)
     {
-        if (StSmplr.ShaderVisibility == ShaderVisibility &&
-            StreqSuff(SamplerName, StSmplr.SamplerDesc.SamplerOrTextureName, SamplerSuffix))
+        if (ImtblSmplr.ShaderVisibility == ShaderVisibility &&
+            StreqSuff(SamplerName, ImtblSmplr.SamplerDesc.SamplerOrTextureName, SamplerSuffix))
         {
-            StSmplr.ShaderRegister = SamplerAttribs.BindPoint;
-            StSmplr.ArraySize      = SamplerAttribs.BindCount;
-            StSmplr.RegisterSpace  = 0;
-            SamplerFound           = true;
+            ImtblSmplr.ShaderRegister = SamplerAttribs.BindPoint;
+            ImtblSmplr.ArraySize      = SamplerAttribs.BindCount;
+            ImtblSmplr.RegisterSpace  = 0;
+
+            SamplerFound = true;
             break;
         }
     }
 
     if (!SamplerFound)
     {
-        LOG_ERROR("Unable to find static sampler \'", SamplerName, '\'');
+        LOG_ERROR("Unable to find immutable sampler \'", SamplerName, '\'');
     }
 }
 
@@ -446,19 +447,19 @@ void RootSignature::dbgVerifyRootParameters() const
 }
 #endif
 
-void RootSignature::AllocateStaticSamplers(const PipelineResourceLayoutDesc& ResourceLayout)
+void RootSignature::AllocateImmutableSamplers(const PipelineResourceLayoutDesc& ResourceLayout)
 {
-    if (ResourceLayout.NumStaticSamplers > 0)
+    if (ResourceLayout.NumImmutableSamplers > 0)
     {
-        m_StaticSamplers.reserve(ResourceLayout.NumStaticSamplers);
-        for (Uint32 sam = 0; sam < ResourceLayout.NumStaticSamplers; ++sam)
+        m_ImmutableSamplers.reserve(ResourceLayout.NumImmutableSamplers);
+        for (Uint32 sam = 0; sam < ResourceLayout.NumImmutableSamplers; ++sam)
         {
-            const auto& StSamDesc    = ResourceLayout.StaticSamplers[sam];
-            Uint32      ShaderStages = StSamDesc.ShaderStages;
+            const auto& ImtblSamDesc = ResourceLayout.ImmutableSamplers[sam];
+            Uint32      ShaderStages = ImtblSamDesc.ShaderStages;
             while (ShaderStages != 0)
             {
                 auto Stage = ShaderStages & ~(ShaderStages - 1);
-                m_StaticSamplers.emplace_back(StSamDesc, GetShaderVisibility(static_cast<SHADER_TYPE>(Stage)));
+                m_ImmutableSamplers.emplace_back(ImtblSamDesc, GetShaderVisibility(static_cast<SHADER_TYPE>(Stage)));
                 ShaderStages &= ~Stage;
             }
         }
@@ -516,19 +517,19 @@ void RootSignature::Finalize(ID3D12Device* pd3d12Device)
     rootSignatureDesc.pParameters   = D3D12Parameters.size() ? D3D12Parameters.data() : nullptr;
 
     UINT TotalD3D12StaticSamplers = 0;
-    for (const auto& StSam : m_StaticSamplers)
-        TotalD3D12StaticSamplers += StSam.ArraySize;
+    for (const auto& ImtblSam : m_ImmutableSamplers)
+        TotalD3D12StaticSamplers += ImtblSam.ArraySize;
     rootSignatureDesc.NumStaticSamplers = TotalD3D12StaticSamplers;
     rootSignatureDesc.pStaticSamplers   = nullptr;
     std::vector<D3D12_STATIC_SAMPLER_DESC, STDAllocatorRawMem<D3D12_STATIC_SAMPLER_DESC>> D3D12StaticSamplers(STD_ALLOCATOR_RAW_MEM(D3D12_STATIC_SAMPLER_DESC, GetRawAllocator(), "Allocator for vector<D3D12_STATIC_SAMPLER_DESC>"));
     D3D12StaticSamplers.reserve(TotalD3D12StaticSamplers);
-    if (!m_StaticSamplers.empty())
+    if (!m_ImmutableSamplers.empty())
     {
-        for (size_t s = 0; s < m_StaticSamplers.size(); ++s)
+        for (size_t s = 0; s < m_ImmutableSamplers.size(); ++s)
         {
-            const auto& StSmplrDesc = m_StaticSamplers[s];
-            const auto& SamDesc     = StSmplrDesc.SamplerDesc.Desc;
-            for (UINT ArrInd = 0; ArrInd < StSmplrDesc.ArraySize; ++ArrInd)
+            const auto& ImtblSmplrDesc = m_ImmutableSamplers[s];
+            const auto& SamDesc        = ImtblSmplrDesc.SamplerDesc.Desc;
+            for (UINT ArrInd = 0; ArrInd < ImtblSmplrDesc.ArraySize; ++ArrInd)
             {
                 D3D12StaticSamplers.emplace_back(
                     D3D12_STATIC_SAMPLER_DESC //
@@ -543,18 +544,18 @@ void RootSignature::Finalize(ID3D12Device* pd3d12Device)
                         BorderColorToD3D12StaticBorderColor(SamDesc.BorderColor),
                         SamDesc.MinLOD,
                         SamDesc.MaxLOD,
-                        StSmplrDesc.ShaderRegister + ArrInd,
-                        StSmplrDesc.RegisterSpace,
-                        StSmplrDesc.ShaderVisibility //
-                    }                                //
+                        ImtblSmplrDesc.ShaderRegister + ArrInd,
+                        ImtblSmplrDesc.RegisterSpace,
+                        ImtblSmplrDesc.ShaderVisibility //
+                    }                                   //
                 );
             }
         }
         rootSignatureDesc.pStaticSamplers = D3D12StaticSamplers.data();
 
-        // Release static samplers array, we no longer need it
-        std::vector<StaticSamplerAttribs, STDAllocatorRawMem<StaticSamplerAttribs>> EmptySamplers(STD_ALLOCATOR_RAW_MEM(StaticSamplerAttribs, GetRawAllocator(), "Allocator for vector<StaticSamplerAttribs>"));
-        m_StaticSamplers.swap(EmptySamplers);
+        // Release immutable samplers array, we no longer need it
+        std::vector<ImmutableSamplerAttribs, STDAllocatorRawMem<ImmutableSamplerAttribs>> EmptySamplers(STD_ALLOCATOR_RAW_MEM(ImmutableSamplerAttribs, GetRawAllocator(), "Allocator for vector<ImmutableSamplerAttribs>"));
+        m_ImmutableSamplers.swap(EmptySamplers);
 
         VERIFY_EXPR(D3D12StaticSamplers.size() == TotalD3D12StaticSamplers);
     }
@@ -640,7 +641,7 @@ void RootSignature::InitResourceCache(RenderDeviceD3D12Impl*    pDeviceD3D12Impl
         DEV_CHECK_ERR(!SamplerHeapSpace.IsNull(),
                       "Failed to allocate ", TotalSamplerDescriptors, " GPU-visible Sampler descriptor",
                       (TotalSamplerDescriptors > 1 ? "s" : ""),
-                      ". Consider using static samplers in the Pipeline State Object or "
+                      ". Consider using immutable samplers in the Pipeline State Object or "
                       "increasing GPUDescriptorHeapSize[1] in EngineD3D12CreateInfo.");
     }
     VERIFY_EXPR(TotalSamplerDescriptors == 0 && SamplerHeapSpace.IsNull() || SamplerHeapSpace.GetNumHandles() == TotalSamplerDescriptors);
@@ -965,7 +966,7 @@ void RootSignature::CommitDescriptorHandlesInternal_SMD(RenderDeviceD3D12Impl*
         DEV_CHECK_ERR(DynamicSamplerDescriptors.GetDescriptorHeap() != nullptr,
                       "Failed to allocate ", NumDynamicSamplerDescriptors, " dynamic GPU-visible Sampler descriptor",
                       (NumDynamicSamplerDescriptors > 1 ? "s" : ""),
-                      ". Consider using static samplers in the Pipeline State Object, increasing GPUDescriptorHeapDynamicSize[1] in "
+                      ". Consider using immutable samplers in the Pipeline State Object, increasing GPUDescriptorHeapDynamicSize[1] in "
                       "EngineD3D12CreateInfo, or optimizing dynamic resource utilization by using static or mutable shader resource variables instead.");
     }
 
diff --git a/Graphics/GraphicsEngineD3D12/src/ShaderResourceBindingD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderResourceBindingD3D12Impl.cpp
index 257a4688..1511bd01 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderResourceBindingD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderResourceBindingD3D12Impl.cpp
@@ -30,6 +30,7 @@
 #include "PipelineStateD3D12Impl.hpp"
 #include "ShaderD3D12Impl.hpp"
 #include "RenderDeviceD3D12Impl.hpp"
+#include "LinearAllocator.hpp"
 
 namespace Diligent
 {
@@ -45,56 +46,76 @@ ShaderResourceBindingD3D12Impl::ShaderResourceBindingD3D12Impl(IReferenceCounter
         IsPSOInternal
     },
     m_ShaderResourceCache{ShaderResourceCacheD3D12::DbgCacheContentType::SRBResources},
-    m_NumShaders         {static_cast<decltype(m_NumShaders)>(pPSO->GetNumShaders())}
+    m_NumShaders         {static_cast<decltype(m_NumShaders)>(pPSO->GetNumShaderStages())}
 // clang-format on
 {
-    m_ResourceLayoutIndex.fill(-1);
-    auto* ppShaders = pPSO->GetShaders();
+    try
+    {
+        m_ResourceLayoutIndex.fill(-1);
 
-    auto* pRenderDeviceD3D12Impl = ValidatedCast<RenderDeviceD3D12Impl>(pPSO->GetDevice());
-    auto& ResCacheDataAllocator  = pPSO->GetSRBMemoryAllocator().GetResourceCacheDataAllocator(0);
-    pPSO->GetRootSignature().InitResourceCache(pRenderDeviceD3D12Impl, m_ShaderResourceCache, ResCacheDataAllocator);
+        LinearAllocator MemPool{GetRawAllocator()};
+        MemPool.AddSpace<ShaderVariableManagerD3D12>(m_NumShaders);
+        MemPool.Reserve();
+        m_pShaderVarMgrs = MemPool.ConstructArray<ShaderVariableManagerD3D12>(m_NumShaders, std::ref(*this), std::ref(m_ShaderResourceCache));
 
-    m_pShaderVarMgrs = ALLOCATE(GetRawAllocator(), "Raw memory for ShaderVariableManagerD3D12", ShaderVariableManagerD3D12, m_NumShaders);
+        // The memory is now owned by ShaderResourceBindingD3D12Impl and will be freed by Destruct().
+        auto* Ptr = MemPool.ReleaseOwnership();
+        VERIFY_EXPR(Ptr == m_pShaderVarMgrs);
+        (void)Ptr;
 
-    for (Uint32 s = 0; s < m_NumShaders; ++s)
-    {
-        auto* pShader    = ppShaders[s];
-        auto  ShaderType = pShader->GetDesc().ShaderType;
-        auto  ShaderInd  = GetShaderTypePipelineIndex(ShaderType, pPSO->GetDesc().PipelineType);
-
-        auto& VarDataAllocator = pPSO->GetSRBMemoryAllocator().GetShaderVariableDataAllocator(s);
-
-        // http://diligentgraphics.com/diligent-engine/architecture/d3d12/shader-resource-layout#Initializing-Resource-Layouts-in-a-Shader-Resource-Binding-Object
-        const SHADER_RESOURCE_VARIABLE_TYPE AllowedVarTypes[] = {SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC};
-        const auto&                         SrcLayout         = pPSO->GetShaderResLayout(s);
-        // Create shader variable manager in place
-        new (m_pShaderVarMgrs + s)
-            ShaderVariableManagerD3D12 //
-            {
-                *this,
+        // It is important to construct all objects before initializing them because if an exception is thrown,
+        // destructors will be called for all objects
+
+        auto* pRenderDeviceD3D12Impl = ValidatedCast<RenderDeviceD3D12Impl>(pPSO->GetDevice());
+        auto& ResCacheDataAllocator  = pPSO->GetSRBMemoryAllocator().GetResourceCacheDataAllocator(0);
+        pPSO->GetRootSignature().InitResourceCache(pRenderDeviceD3D12Impl, m_ShaderResourceCache, ResCacheDataAllocator);
+
+        for (Uint32 s = 0; s < m_NumShaders; ++s)
+        {
+            const auto  ShaderType = pPSO->GetShaderStageType(s);
+            const auto& SrcLayout  = pPSO->GetShaderResLayout(s);
+            const auto  ShaderInd  = GetShaderTypePipelineIndex(ShaderType, pPSO->GetDesc().PipelineType);
+
+            auto& VarDataAllocator = pPSO->GetSRBMemoryAllocator().GetShaderVariableDataAllocator(s);
+
+            // http://diligentgraphics.com/diligent-engine/architecture/d3d12/shader-resource-layout#Initializing-Resource-Layouts-in-a-Shader-Resource-Binding-Object
+            const SHADER_RESOURCE_VARIABLE_TYPE AllowedVarTypes[] = {SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC};
+            m_pShaderVarMgrs[s].Initialize(
                 SrcLayout,
                 VarDataAllocator,
                 AllowedVarTypes,
-                _countof(AllowedVarTypes),
-                m_ShaderResourceCache //
-            };
+                _countof(AllowedVarTypes) //
+            );
 
-        m_ResourceLayoutIndex[ShaderInd] = static_cast<Int8>(s);
+            m_ResourceLayoutIndex[ShaderInd] = static_cast<Int8>(s);
+        }
+    }
+    catch (...)
+    {
+        Destruct();
+        throw;
     }
 }
 
+
 ShaderResourceBindingD3D12Impl::~ShaderResourceBindingD3D12Impl()
 {
-    auto* pPSO = ValidatedCast<PipelineStateD3D12Impl>(m_pPSO);
-    for (Uint32 s = 0; s < m_NumShaders; ++s)
+    Destruct();
+}
+
+void ShaderResourceBindingD3D12Impl::Destruct()
+{
+    if (m_pShaderVarMgrs != nullptr)
     {
-        auto& VarDataAllocator = pPSO->GetSRBMemoryAllocator().GetShaderVariableDataAllocator(s);
-        m_pShaderVarMgrs[s].Destroy(VarDataAllocator);
-        m_pShaderVarMgrs[s].~ShaderVariableManagerD3D12();
+        auto& SRBMemAllocator = m_pPSO->GetSRBMemoryAllocator();
+        for (Uint32 s = 0; s < m_NumShaders; ++s)
+        {
+            auto& VarDataAllocator = SRBMemAllocator.GetShaderVariableDataAllocator(s);
+            m_pShaderVarMgrs[s].Destroy(VarDataAllocator);
+            m_pShaderVarMgrs[s].~ShaderVariableManagerD3D12();
+        }
+        GetRawAllocator().Free(m_pShaderVarMgrs);
     }
-
-    GetRawAllocator().Free(m_pShaderVarMgrs);
 }
 
 IMPLEMENT_QUERY_INTERFACE(ShaderResourceBindingD3D12Impl, IID_ShaderResourceBindingD3D12, TBase)
@@ -189,20 +210,20 @@ void ShaderResourceBindingD3D12Impl::InitializeStaticResources(const IPipelineSt
     }
 
     auto* pPSO12     = ValidatedCast<const PipelineStateD3D12Impl>(pPSO);
-    auto  NumShaders = pPSO12->GetNumShaders();
+    auto  NumShaders = pPSO12->GetNumShaderStages();
     // Copy static resources
     for (Uint32 s = 0; s < NumShaders; ++s)
     {
         const auto& ShaderResLayout = pPSO12->GetShaderResLayout(s);
         auto&       StaticResLayout = pPSO12->GetStaticShaderResLayout(s);
         auto&       StaticResCache  = pPSO12->GetStaticShaderResCache(s);
+
 #ifdef DILIGENT_DEVELOPMENT
         if (!StaticResLayout.dvpVerifyBindings(StaticResCache))
         {
-            auto* pShader = pPSO12->GetShader<ShaderD3D12Impl>(s);
             LOG_ERROR_MESSAGE("Static resources in SRB of PSO '", pPSO12->GetDesc().Name,
-                              "' will not be successfully initialized because not all static resource bindings in shader '",
-                              pShader->GetDesc().Name,
+                              "' will not be successfully initialized because not all static resource bindings in shader type '",
+                              GetShaderTypeLiteralName(pPSO12->GetShaderStageType(s)),
                               "' are valid. Please make sure you bind all static resources to PSO before calling InitializeStaticResources() "
                               "directly or indirectly by passing InitStaticResources=true to CreateShaderResourceBinding() method.");
         }
diff --git a/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
index 6c313882..c0428e7e 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
@@ -38,6 +38,7 @@
 #include "RootSignature.hpp"
 #include "PipelineStateD3D12Impl.hpp"
 #include "ShaderResourceVariableBase.hpp"
+#include "ShaderVariableD3DBase.hpp"
 
 namespace Diligent
 {
@@ -112,22 +113,19 @@ void ShaderResourceLayoutD3D12::AllocateMemory(IMemoryAllocator&
 
 // http://diligentgraphics.com/diligent-engine/architecture/d3d12/shader-resource-layout#Initializing-Shader-Resource-Layouts-and-Root-Signature-in-a-Pipeline-State-Object
 // http://diligentgraphics.com/diligent-engine/architecture/d3d12/shader-resource-cache#Initializing-Shader-Resource-Layouts-in-a-Pipeline-State
-ShaderResourceLayoutD3D12::ShaderResourceLayoutD3D12(IObject&                                    Owner,
-                                                     ID3D12Device*                               pd3d12Device,
-                                                     PIPELINE_TYPE                               PipelineType,
-                                                     const PipelineResourceLayoutDesc&           ResourceLayout,
-                                                     std::shared_ptr<const ShaderResourcesD3D12> pSrcResources,
-                                                     IMemoryAllocator&                           LayoutDataAllocator,
-                                                     const SHADER_RESOURCE_VARIABLE_TYPE* const  AllowedVarTypes,
-                                                     Uint32                                      NumAllowedTypes,
-                                                     ShaderResourceCacheD3D12*                   pResourceCache,
-                                                     RootSignature*                              pRootSig) :
-    // clang-format off
-    m_Owner        {Owner},
-    m_pd3d12Device {pd3d12Device},
-    m_pResources   {std::move(pSrcResources)}
-// clang-format on
+void ShaderResourceLayoutD3D12::Initialize(ID3D12Device*                               pd3d12Device,
+                                           PIPELINE_TYPE                               PipelineType,
+                                           const PipelineResourceLayoutDesc&           ResourceLayout,
+                                           std::shared_ptr<const ShaderResourcesD3D12> pSrcResources,
+                                           IMemoryAllocator&                           LayoutDataAllocator,
+                                           const SHADER_RESOURCE_VARIABLE_TYPE* const  AllowedVarTypes,
+                                           Uint32                                      NumAllowedTypes,
+                                           ShaderResourceCacheD3D12*                   pResourceCache,
+                                           RootSignature*                              pRootSig)
 {
+    m_pd3d12Device = pd3d12Device;
+    m_pResources   = std::move(pSrcResources);
+
     VERIFY_EXPR((pResourceCache != nullptr) ^ (pRootSig != nullptr));
 
     const Uint32 AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes);
@@ -148,10 +146,11 @@ ShaderResourceLayoutD3D12::ShaderResourceLayoutD3D12(IObject&
             auto VarType = m_pResources->FindVariableType(Sam, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
             {
-                constexpr bool LogStaticSamplerArrayError = true;
-                auto           StaticSamplerInd           = m_pResources->FindStaticSampler(Sam, ResourceLayout, LogStaticSamplerArrayError);
-                // Skip static samplers
-                if (StaticSamplerInd < 0)
+                constexpr bool LogImtblSamplerArrayError = true;
+
+                auto ImtblSamplerInd = m_pResources->FindImmutableSampler(Sam, ResourceLayout, LogImtblSamplerArrayError);
+                // Skip immutable samplers
+                if (ImtblSamplerInd < 0)
                     ++SamplerCount[VarType];
             }
         },
@@ -236,7 +235,7 @@ ShaderResourceLayoutD3D12::ShaderResourceLayoutD3D12(IObject&
         VERIFY(RootIndex != D3D12Resource::InvalidRootIndex, "Root index must be valid");
         VERIFY(Offset != D3D12Resource::InvalidOffset, "Offset must be valid");
 
-        // Static samplers are never copied, and SamplerId == InvalidSamplerId
+        // Immutable samplers are never copied, and SamplerId == InvalidSamplerId
         auto& NewResource = (ResType == CachedResourceType::Sampler) ?
             GetSampler(VarType, CurrSampler[VarType]++) :
             GetSrvCbvUav(VarType, CurrCbvSrvUav[VarType]++);
@@ -257,12 +256,13 @@ ShaderResourceLayoutD3D12::ShaderResourceLayoutD3D12(IObject&
             if (IsAllowedType(VarType, AllowedTypeBits))
             {
                 // The error (if any) have already been logged when counting the resources
-                constexpr bool LogStaticSamplerArrayError = false;
-                auto           StaticSamplerInd           = m_pResources->FindStaticSampler(Sam, ResourceLayout, LogStaticSamplerArrayError);
-                if (StaticSamplerInd >= 0)
+                constexpr bool LogImtblSamplerArrayError = false;
+
+                auto ImtblSamplerInd = m_pResources->FindImmutableSampler(Sam, ResourceLayout, LogImtblSamplerArrayError);
+                if (ImtblSamplerInd >= 0)
                 {
                     if (pRootSig != nullptr)
-                        pRootSig->InitStaticSampler(m_pResources->GetShaderType(), Sam.Name, m_pResources->GetCombinedSamplerSuffix(), Sam);
+                        pRootSig->InitImmutableSampler(m_pResources->GetShaderType(), Sam.Name, m_pResources->GetCombinedSamplerSuffix(), Sam);
                 }
                 else
                 {
@@ -289,18 +289,19 @@ ShaderResourceLayoutD3D12::ShaderResourceLayoutD3D12(IObject&
                                   ") of the sampler '", SamplerAttribs.Name, "' that is assigned to it");
 
                     // The error (if any) have already been logged when counting the resources
-                    constexpr bool LogStaticSamplerArrayError = false;
-                    auto           StaticSamplerInd           = m_pResources->FindStaticSampler(SamplerAttribs, ResourceLayout, LogStaticSamplerArrayError);
-                    if (StaticSamplerInd >= 0)
+                    constexpr bool LogImtblSamplerArrayError = false;
+
+                    auto ImtblSamplerInd = m_pResources->FindImmutableSampler(SamplerAttribs, ResourceLayout, LogImtblSamplerArrayError);
+                    if (ImtblSamplerInd >= 0)
                     {
-                    // Static samplers are never copied, and SamplerId == InvalidSamplerId
+                    // Immutable samplers are never copied, and SamplerId == InvalidSamplerId
 #ifdef DILIGENT_DEBUG
                         auto SamplerCount = GetTotalSamplerCount();
                         for (Uint32 s = 0; s < SamplerCount; ++s)
                         {
                             const auto& Sampler = GetSampler(s);
                             if (strcmp(Sampler.Attribs.Name, SamplerAttribs.Name) == 0)
-                                LOG_ERROR("Static sampler '", Sampler.Attribs.Name, "' was found among resources. This seems to be a bug");
+                                LOG_ERROR("Immutable sampler '", Sampler.Attribs.Name, "' was found among resources. This seems to be a bug");
                         }
 #endif
                     }
@@ -429,6 +430,11 @@ template <>
 struct ResourceViewTraits<ITextureViewD3D12>
 {
     static const INTERFACE_ID& IID;
+
+    static bool VerifyView(ITextureViewD3D12* pViewD3D12, const D3DShaderResourceAttribs& Attribs, const char* ShaderName)
+    {
+        return true;
+    }
 };
 const INTERFACE_ID& ResourceViewTraits<ITextureViewD3D12>::IID = IID_TextureViewD3D12;
 
@@ -436,6 +442,11 @@ template <>
 struct ResourceViewTraits<IBufferViewD3D12>
 {
     static const INTERFACE_ID& IID;
+
+    static bool VerifyView(IBufferViewD3D12* pViewD3D12, const D3DShaderResourceAttribs& Attribs, const char* ShaderName)
+    {
+        return VerifyBufferViewModeD3D(pViewD3D12, Attribs, ShaderName);
+    }
 };
 const INTERFACE_ID& ResourceViewTraits<IBufferViewD3D12>::IID = IID_BufferViewD3D12;
 
@@ -451,9 +462,10 @@ void ShaderResourceLayoutD3D12::D3D12Resource::CacheResourceView(IDeviceObject*
 {
     // We cannot use ValidatedCast<> here as the resource retrieved from the
     // resource mapping can be of wrong type
-    RefCntAutoPtr<TResourceViewType> pViewD3D12(pView, ResourceViewTraits<TResourceViewType>::IID);
+    RefCntAutoPtr<TResourceViewType> pViewD3D12{pView, ResourceViewTraits<TResourceViewType>::IID};
 #ifdef DILIGENT_DEVELOPMENT
     VerifyResourceViewBinding(Attribs, GetVariableType(), ArrayIndex, pView, pViewD3D12.RawPtr(), {dbgExpectedViewType}, DstRes.pObject.RawPtr(), ParentResLayout.GetShaderName());
+    ResourceViewTraits<TResourceViewType>::VerifyView(pViewD3D12, Attribs, ParentResLayout.GetShaderName());
 #endif
     if (pViewD3D12)
     {
@@ -607,7 +619,7 @@ void ShaderResourceLayoutD3D12::D3D12Resource::BindResource(IDeviceObject*
                         if (ValidSamplerAssigned())
                         {
                             auto& Sam = ParentResLayout.GetAssignedSampler(*this);
-                            //VERIFY( !Sam.Attribs.IsStaticSampler(), "Static samplers should never be assigned space in the cache" );
+                            //VERIFY( !Sam.Attribs.IsImmutableSampler(), "Immutable samplers should never be assigned space in the cache" );
                             VERIFY_EXPR(Attribs.BindCount == Sam.Attribs.BindCount || Sam.Attribs.BindCount == 1);
                             auto SamplerArrInd = Sam.Attribs.BindCount > 1 ? ArrayIndex : 0;
 
@@ -781,7 +793,7 @@ void ShaderResourceLayoutD3D12::CopyStaticResourceDesriptorHandles(const ShaderR
         {
             const auto& SamInfo = DstLayout.GetAssignedSampler(res);
 
-            //VERIFY(!SamInfo.Attribs.IsStaticSampler(), "Static samplers should never be assigned space in the cache");
+            //VERIFY(!SamInfo.Attribs.IsImmutableSampler(), "Immutable samplers should never be assigned space in the cache");
 
             VERIFY(SamInfo.Attribs.IsValidBindPoint(), "Sampler bind point must be valid");
             VERIFY_EXPR(SamInfo.Attribs.BindCount == res.Attribs.BindCount || SamInfo.Attribs.BindCount == 1);
@@ -908,7 +920,7 @@ bool ShaderResourceLayoutD3D12::dvpVerifyBindings(const ShaderResourceCacheD3D12
             {
                 VERIFY(res.GetResType() == CachedResourceType::TexSRV, "Sampler can only be assigned to a texture SRV");
                 const auto& SamInfo = GetAssignedSampler(res);
-                //VERIFY(!SamInfo.Attribs.IsStaticSampler(), "Static samplers should never be assigned space in the cache" );
+                //VERIFY(!SamInfo.Attribs.IsImmutableSampler(), "Immutable samplers should never be assigned space in the cache" );
                 VERIFY(SamInfo.Attribs.IsValidBindPoint(), "Sampler bind point must be valid");
 
                 for (Uint32 ArrInd = 0; ArrInd < SamInfo.Attribs.BindCount; ++ArrInd)
diff --git a/Graphics/GraphicsEngineD3D12/src/ShaderVariableD3D12.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderVariableD3D12.cpp
index f7c23096..fd58eacf 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderVariableD3D12.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderVariableD3D12.cpp
@@ -54,20 +54,15 @@ size_t ShaderVariableManagerD3D12::GetRequiredMemorySize(const ShaderResourceLay
 }
 
 // Creates shader variable for every resource from SrcLayout whose type is one AllowedVarTypes
-ShaderVariableManagerD3D12::ShaderVariableManagerD3D12(IObject&                             Owner,
-                                                       const ShaderResourceLayoutD3D12&     SrcLayout,
-                                                       IMemoryAllocator&                    Allocator,
-                                                       const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
-                                                       Uint32                               NumAllowedTypes,
-                                                       ShaderResourceCacheD3D12&            ResourceCache) :
-    // clang-format off
-    m_Owner         {Owner},
-    m_ResourceCache {ResourceCache}
+void ShaderVariableManagerD3D12::Initialize(const ShaderResourceLayoutD3D12&     SrcLayout,
+                                            IMemoryAllocator&                    Allocator,
+                                            const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
+                                            Uint32                               NumAllowedTypes)
+{
 #ifdef DILIGENT_DEBUG
-  , m_DbgAllocator  {Allocator}
+    m_pDbgAllocator = &Allocator;
 #endif
-// clang-format on
-{
+
     const Uint32 AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes);
     VERIFY_EXPR(m_NumVariables == 0);
     auto MemSize = GetRequiredMemorySize(SrcLayout, AllowedVarTypes, NumAllowedTypes, m_NumVariables);
@@ -113,10 +108,10 @@ ShaderVariableManagerD3D12::~ShaderVariableManagerD3D12()
 
 void ShaderVariableManagerD3D12::Destroy(IMemoryAllocator& Allocator)
 {
-    VERIFY(&m_DbgAllocator == &Allocator, "Incosistent alloctor");
-
     if (m_pVariables != nullptr)
     {
+        VERIFY(m_pDbgAllocator == &Allocator, "Incosistent alloctor");
+
         for (Uint32 v = 0; v < m_NumVariables; ++v)
             m_pVariables[v].~ShaderVariableD3D12Impl();
         Allocator.Free(m_pVariables);
diff --git a/Graphics/GraphicsEngineD3D12/src/TextureD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/TextureD3D12Impl.cpp
index a4033f51..22829770 100644
--- a/Graphics/GraphicsEngineD3D12/src/TextureD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/TextureD3D12Impl.cpp
@@ -135,8 +135,8 @@ TextureD3D12Impl::TextureD3D12Impl(IReferenceCounters*        pRefCounters,
                                    const TextureData*         pInitData /*= nullptr*/) :
     TTextureBase{pRefCounters, TexViewObjAllocator, pRenderDeviceD3D12, TexDesc}
 {
-    if (m_Desc.Usage == USAGE_STATIC && (pInitData == nullptr || pInitData->pSubResources == nullptr))
-        LOG_ERROR_AND_THROW("Static textures must be initialized with data at creation time: pInitData can't be null");
+    if (m_Desc.Usage == USAGE_IMMUTABLE && (pInitData == nullptr || pInitData->pSubResources == nullptr))
+        LOG_ERROR_AND_THROW("Immutable textures must be initialized with data at creation time: pInitData can't be null");
 
     if ((m_Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS) != 0)
     {
@@ -149,7 +149,7 @@ TextureD3D12Impl::TextureD3D12Impl(IReferenceCounters*        pRefCounters,
     D3D12_RESOURCE_DESC Desc = GetD3D12TextureDesc();
 
     auto* pd3d12Device = pRenderDeviceD3D12->GetD3D12Device();
-    if (m_Desc.Usage == USAGE_STATIC || m_Desc.Usage == USAGE_DEFAULT || m_Desc.Usage == USAGE_DYNAMIC)
+    if (m_Desc.Usage == USAGE_IMMUTABLE || m_Desc.Usage == USAGE_DEFAULT || m_Desc.Usage == USAGE_DYNAMIC)
     {
         D3D12_CLEAR_VALUE  ClearValue  = {};
         D3D12_CLEAR_VALUE* pClearValue = nullptr;