Renamed static sampler to immutable sampler (API240076)

26 files changed, 268 insertions, 259 deletions

diff --git a/Graphics/GraphicsEngine/include/PipelineStateBase.hpp b/Graphics/GraphicsEngine/include/PipelineStateBase.hpp
index cda2247e..c108f663 100644
--- a/Graphics/GraphicsEngine/include/PipelineStateBase.hpp
+++ b/Graphics/GraphicsEngine/include/PipelineStateBase.hpp
@@ -460,13 +460,13 @@ private:
             }
         }
 
-        if (SrcLayout.StaticSamplers != nullptr)
+        if (SrcLayout.ImmutableSamplers != nullptr)
         {
-            MemPool.AddSpace<StaticSamplerDesc>(SrcLayout.NumStaticSamplers);
-            for (Uint32 i = 0; i < SrcLayout.NumStaticSamplers; ++i)
+            MemPool.AddSpace<ImmutableSamplerDesc>(SrcLayout.NumImmutableSamplers);
+            for (Uint32 i = 0; i < SrcLayout.NumImmutableSamplers; ++i)
             {
-                VERIFY(SrcLayout.StaticSamplers[i].SamplerOrTextureName != nullptr, "Static sampler or texture name can't be null");
-                MemPool.AddSpaceForString(SrcLayout.StaticSamplers[i].SamplerOrTextureName);
+                VERIFY(SrcLayout.ImmutableSamplers[i].SamplerOrTextureName != nullptr, "Immutable sampler or texture name can't be null");
+                MemPool.AddSpaceForString(SrcLayout.ImmutableSamplers[i].SamplerOrTextureName);
             }
         }
     }
@@ -485,13 +485,13 @@ private:
             }
         }
 
-        if (SrcLayout.StaticSamplers != nullptr)
+        if (SrcLayout.ImmutableSamplers != nullptr)
         {
-            auto* StaticSamplers     = MemPool.Allocate<StaticSamplerDesc>(SrcLayout.NumStaticSamplers);
-            DstLayout.StaticSamplers = StaticSamplers;
-            for (Uint32 i = 0; i < SrcLayout.NumStaticSamplers; ++i)
+            auto* ImmutableSamplers     = MemPool.Allocate<ImmutableSamplerDesc>(SrcLayout.NumImmutableSamplers);
+            DstLayout.ImmutableSamplers = ImmutableSamplers;
+            for (Uint32 i = 0; i < SrcLayout.NumImmutableSamplers; ++i)
             {
-                const auto& SrcSmplr = SrcLayout.StaticSamplers[i];
+                const auto& SrcSmplr = SrcLayout.ImmutableSamplers[i];
 #ifdef DILIGENT_DEVELOPMENT
                 {
                     const auto& BorderColor = SrcSmplr.Desc.BorderColor;
@@ -499,15 +499,15 @@ private:
                           (BorderColor[0] == 0 && BorderColor[1] == 0 && BorderColor[2] == 0 && BorderColor[3] == 1) ||
                           (BorderColor[0] == 1 && BorderColor[1] == 1 && BorderColor[2] == 1 && BorderColor[3] == 1)))
                     {
-                        LOG_WARNING_MESSAGE("Static sampler for variable \"", SrcSmplr.SamplerOrTextureName, "\" specifies border color (",
+                        LOG_WARNING_MESSAGE("Immutable sampler for variable \"", SrcSmplr.SamplerOrTextureName, "\" specifies border color (",
                                             BorderColor[0], ", ", BorderColor[1], ", ", BorderColor[2], ", ", BorderColor[3],
                                             "). 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");
                     }
                 }
 #endif
 
-                StaticSamplers[i]                      = SrcSmplr;
-                StaticSamplers[i].SamplerOrTextureName = MemPool.CopyString(SrcSmplr.SamplerOrTextureName);
+                ImmutableSamplers[i]                      = SrcSmplr;
+                ImmutableSamplers[i].SamplerOrTextureName = MemPool.CopyString(SrcSmplr.SamplerOrTextureName);
             }
         }
     }
diff --git a/Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp b/Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp
index 78c1832d..1130fbff 100644
--- a/Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp
+++ b/Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp
@@ -115,15 +115,15 @@ inline Uint32 GetAllowedTypeBits(const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVar
     return AllowedTypeBits;
 }
 
-inline Int32 FindStaticSampler(const StaticSamplerDesc* StaticSamplers,
-                               Uint32                   NumStaticSamplers,
-                               SHADER_TYPE              ShaderType,
-                               const char*              ResourceName,
-                               const char*              SamplerSuffix)
+inline Int32 FindImmutableSampler(const ImmutableSamplerDesc* ImtblSamplers,
+                                  Uint32                      NumImtblSamplers,
+                                  SHADER_TYPE                 ShaderType,
+                                  const char*                 ResourceName,
+                                  const char*                 SamplerSuffix)
 {
-    for (Uint32 s = 0; s < NumStaticSamplers; ++s)
+    for (Uint32 s = 0; s < NumImtblSamplers; ++s)
     {
-        const auto& StSam = StaticSamplers[s];
+        const auto& StSam = ImtblSamplers[s];
         if (((StSam.ShaderStages & ShaderType) != 0) && StreqSuff(ResourceName, StSam.SamplerOrTextureName, SamplerSuffix))
             return s;
     }
diff --git a/Graphics/GraphicsEngine/interface/APIInfo.h b/Graphics/GraphicsEngine/interface/APIInfo.h
index 10cf096e..a32511d2 100644
--- a/Graphics/GraphicsEngine/interface/APIInfo.h
+++ b/Graphics/GraphicsEngine/interface/APIInfo.h
@@ -30,7 +30,7 @@
 /// \file
 /// Diligent API information
 
-#define DILIGENT_API_VERSION 240075
+#define DILIGENT_API_VERSION 240076
 
 #include "../../../Primitives/interface/BasicTypes.h"
 
@@ -77,7 +77,7 @@ struct APIInfo
     size_t InputLayoutDescSize                 DEFAULT_INITIALIZER(0);
     size_t SampleDescSize                      DEFAULT_INITIALIZER(0);
     size_t ShaderResourceVariableDescSize      DEFAULT_INITIALIZER(0);
-    size_t StaticSamplerDescSize               DEFAULT_INITIALIZER(0);
+    size_t ImmutableSamplerDescSize            DEFAULT_INITIALIZER(0);
     size_t PipelineResourceLayoutDescSize      DEFAULT_INITIALIZER(0);
     size_t GraphicsPipelineDescSize            DEFAULT_INITIALIZER(0);
     size_t GraphicsPipelineStateCreateInfoSize DEFAULT_INITIALIZER(0);
diff --git a/Graphics/GraphicsEngine/interface/PipelineState.h b/Graphics/GraphicsEngine/interface/PipelineState.h
index cef07c66..2d889c61 100644
--- a/Graphics/GraphicsEngine/interface/PipelineState.h
+++ b/Graphics/GraphicsEngine/interface/PipelineState.h
@@ -96,32 +96,36 @@ struct ShaderResourceVariableDesc
 typedef struct ShaderResourceVariableDesc ShaderResourceVariableDesc;
 
 
-/// Static sampler description
-struct StaticSamplerDesc
+/// Immutable sampler description.
+
+/// An immutable sampler is compiled into the pipeline state and can't be changed.
+/// It is generally more efficient than a regular sampler and should be used
+/// whenever possible.
+struct ImmutableSamplerDesc
 {
-    /// Shader stages that this static sampler applies to. More than one shader stage can be specified.
+    /// Shader stages that this immutable sampler applies to. More than one shader stage can be specified.
     SHADER_TYPE ShaderStages         DEFAULT_INITIALIZER(SHADER_TYPE_UNKNOWN);
 
     /// The name of the sampler itself or the name of the texture variable that 
-    /// this static sampler is assigned to if combined texture samplers are used.
+    /// this immutable sampler is assigned to if combined texture samplers are used.
     const Char* SamplerOrTextureName DEFAULT_INITIALIZER(nullptr);
 
     /// Sampler description
     struct SamplerDesc Desc;
 
 #if DILIGENT_CPP_INTERFACE
-    StaticSamplerDesc()noexcept{}
+    ImmutableSamplerDesc()noexcept{}
 
-    StaticSamplerDesc(SHADER_TYPE        _ShaderStages,
-                      const Char*        _SamplerOrTextureName,
-                      const SamplerDesc& _Desc)noexcept : 
+    ImmutableSamplerDesc(SHADER_TYPE        _ShaderStages,
+                         const Char*        _SamplerOrTextureName,
+                         const SamplerDesc& _Desc)noexcept : 
         ShaderStages        {_ShaderStages        },
         SamplerOrTextureName{_SamplerOrTextureName},
         Desc                {_Desc                }
     {}
 #endif
 };
-typedef struct StaticSamplerDesc StaticSamplerDesc;
+typedef struct ImmutableSamplerDesc ImmutableSamplerDesc;
 
 /// Pipeline layout description
 struct PipelineResourceLayoutDesc
@@ -129,19 +133,19 @@ struct PipelineResourceLayoutDesc
     /// Default shader resource variable type. This type will be used if shader
     /// variable description is not found in the Variables array
     /// or if Variables == nullptr
-    SHADER_RESOURCE_VARIABLE_TYPE       DefaultVariableType DEFAULT_INITIALIZER(SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
+    SHADER_RESOURCE_VARIABLE_TYPE       DefaultVariableType  DEFAULT_INITIALIZER(SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
 
     /// Number of elements in Variables array            
-    Uint32                              NumVariables        DEFAULT_INITIALIZER(0);
+    Uint32                              NumVariables         DEFAULT_INITIALIZER(0);
 
     /// Array of shader resource variable descriptions               
-    const ShaderResourceVariableDesc*   Variables           DEFAULT_INITIALIZER(nullptr);
+    const ShaderResourceVariableDesc*   Variables            DEFAULT_INITIALIZER(nullptr);
                                                             
-    /// Number of static samplers in StaticSamplers array   
-    Uint32                              NumStaticSamplers   DEFAULT_INITIALIZER(0);
+    /// Number of immutable samplers in ImmutableSamplers array   
+    Uint32                              NumImmutableSamplers DEFAULT_INITIALIZER(0);
                                                             
-    /// Array of static sampler descriptions                
-    const StaticSamplerDesc*            StaticSamplers      DEFAULT_INITIALIZER(nullptr);
+    /// Array of immutable sampler descriptions                
+    const ImmutableSamplerDesc*         ImmutableSamplers    DEFAULT_INITIALIZER(nullptr);
 };
 typedef struct PipelineResourceLayoutDesc PipelineResourceLayoutDesc;
 
@@ -256,7 +260,7 @@ typedef struct PipelineStateDesc PipelineStateDesc;
 DILIGENT_TYPED_ENUM(PSO_CREATE_FLAGS, Uint32)
 {
     /// Null flag.
-    PSO_CREATE_FLAG_NONE                          = 0x00,
+    PSO_CREATE_FLAG_NONE                              = 0x00,
 
     /// Ignore missing variables.
 
@@ -264,15 +268,15 @@ DILIGENT_TYPED_ENUM(PSO_CREATE_FLAGS, Uint32)
     /// provided as part of the pipeline resource layout description
     /// that is not found in any of the designated shader stages.
     /// Use this flag to silence these warnings.
-    PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES      = 0x01,
+    PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES          = 0x01,
 
-    /// Ignore missing static samplers.
+    /// Ignore missing immutable samplers.
 
-    /// By default, the engine outputs a warning for every static sampler
+    /// By default, the engine outputs a warning for every immutable sampler
     /// provided as part of the pipeline resource layout description
     /// that is not found in any of the designated shader stages.
     /// Use this flag to silence these warnings.
-    PSO_CREATE_FLAG_IGNORE_MISSING_STATIC_SAMPLERS = 0x02,
+    PSO_CREATE_FLAG_IGNORE_MISSING_IMMUTABLE_SAMPLERS = 0x02,
 };
 DEFINE_FLAG_ENUM_OPERATORS(PSO_CREATE_FLAGS);
 
diff --git a/Graphics/GraphicsEngine/src/APIInfo.cpp b/Graphics/GraphicsEngine/src/APIInfo.cpp
index aa2fb3d9..e4111327 100644
--- a/Graphics/GraphicsEngine/src/APIInfo.cpp
+++ b/Graphics/GraphicsEngine/src/APIInfo.cpp
@@ -87,7 +87,7 @@ static APIInfo InitAPIInfo()
     INIT_STRUCTURE_SIZE(InputLayoutDesc);
     INIT_STRUCTURE_SIZE(SampleDesc);
     INIT_STRUCTURE_SIZE(ShaderResourceVariableDesc);
-    INIT_STRUCTURE_SIZE(StaticSamplerDesc);
+    INIT_STRUCTURE_SIZE(ImmutableSamplerDesc);
     INIT_STRUCTURE_SIZE(PipelineResourceLayoutDesc);
     INIT_STRUCTURE_SIZE(GraphicsPipelineDesc);
     INIT_STRUCTURE_SIZE(GraphicsPipelineStateCreateInfo);
diff --git a/Graphics/GraphicsEngineD3D11/include/PipelineStateD3D11Impl.hpp b/Graphics/GraphicsEngineD3D11/include/PipelineStateD3D11Impl.hpp
index eb184710..0fa62606 100644
--- a/Graphics/GraphicsEngineD3D11/include/PipelineStateD3D11Impl.hpp
+++ b/Graphics/GraphicsEngineD3D11/include/PipelineStateD3D11Impl.hpp
@@ -134,7 +134,7 @@ public:
     const ShaderD3D11Impl* GetShaderByType(SHADER_TYPE ShaderType) const;
     const ShaderD3D11Impl* GetShader(Uint32 Index) const;
 
-    void SetStaticSamplers(ShaderResourceCacheD3D11& ResourceCache, Uint32 ShaderInd) const;
+    void SetImmutableSamplers(ShaderResourceCacheD3D11& ResourceCache, Uint32 ShaderInd) const;
 
 private:
     template <typename PSOCreateInfoType>
@@ -166,20 +166,20 @@ private:
     // indexed by the shader type pipeline index (returned by GetShaderTypePipelineIndex)
     std::array<Int8, MAX_SHADERS_IN_PIPELINE> m_ResourceLayoutIndex = {-1, -1, -1, -1, -1};
 
-    std::array<Uint16, MAX_SHADERS_IN_PIPELINE + 1> m_StaticSamplerOffsets = {};
-    struct StaticSamplerInfo
+    std::array<Uint16, MAX_SHADERS_IN_PIPELINE + 1> m_ImmutableSamplerOffsets = {};
+    struct ImmutableSamplerInfo
     {
         const D3DShaderResourceAttribs& Attribs;
         RefCntAutoPtr<ISampler>         pSampler;
-        StaticSamplerInfo(const D3DShaderResourceAttribs& _Attribs,
-                          RefCntAutoPtr<ISampler>         _pSampler) :
+        ImmutableSamplerInfo(const D3DShaderResourceAttribs& _Attribs,
+                             RefCntAutoPtr<ISampler>         _pSampler) :
             // clang-format off
             Attribs  {_Attribs},
             pSampler {std::move(_pSampler)}
         // clang-format on
         {}
     };
-    std::vector<StaticSamplerInfo, STDAllocatorRawMem<StaticSamplerInfo>> m_StaticSamplers;
+    std::vector<ImmutableSamplerInfo, STDAllocatorRawMem<ImmutableSamplerInfo>> m_ImmutableSamplers;
 };
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp
index 292a9323..722318f2 100644
--- a/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp
+++ b/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp
@@ -74,7 +74,7 @@ PipelineStateD3D11Impl::PipelineStateD3D11Impl(IReferenceCounters*
         CreateInfo
     },
     m_SRBMemAllocator{GetRawAllocator()},
-    m_StaticSamplers (STD_ALLOCATOR_RAW_MEM(StaticSamplerInfo, GetRawAllocator(), "Allocator for vector<StaticSamplerInfo>"))
+    m_ImmutableSamplers (STD_ALLOCATOR_RAW_MEM(ImmutableSamplerInfo, GetRawAllocator(), "Allocator for vector<ImmutableSamplerInfo>"))
 // clang-format on
 {
     auto MemPool = InitInternalObjects(CreateInfo);
@@ -153,7 +153,7 @@ PipelineStateD3D11Impl::PipelineStateD3D11Impl(IReferenceCounters*
         CreateInfo
     },
     m_SRBMemAllocator{GetRawAllocator()},
-    m_StaticSamplers (STD_ALLOCATOR_RAW_MEM(StaticSamplerInfo, GetRawAllocator(), "Allocator for vector<StaticSamplerInfo>"))
+    m_ImmutableSamplers(STD_ALLOCATOR_RAW_MEM(ImmutableSamplerInfo, GetRawAllocator(), "Allocator for vector<ImmutableSamplerInfo>"))
 // clang-format on
 {
     auto MemPool = InitInternalObjects(CreateInfo);
@@ -209,11 +209,11 @@ void PipelineStateD3D11Impl::InitResourceLayouts(const PipelineStateCreateInfo&
         }
         ShaderResources::DvpVerifyResourceLayout(ResourceLayout, pResources, GetNumShaderStages(),
                                                  (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES) == 0,
-                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_STATIC_SAMPLERS) == 0);
+                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_IMMUTABLE_SAMPLERS) == 0);
     }
 #endif
 
-    decltype(m_StaticSamplers)                  StaticSamplers(STD_ALLOCATOR_RAW_MEM(StaticSamplerInfo, GetRawAllocator(), "Allocator for vector<StaticSamplerInfo>"));
+    decltype(m_ImmutableSamplers)               ImmutableSamplers(STD_ALLOCATOR_RAW_MEM(ImmutableSamplerInfo, GetRawAllocator(), "Allocator for vector<ImmutableSamplerInfo>"));
     std::array<size_t, MAX_SHADERS_IN_PIPELINE> ShaderResLayoutDataSizes = {};
     std::array<size_t, MAX_SHADERS_IN_PIPELINE> ShaderResCacheDataSizes  = {};
     for (Uint32 s = 0; s < ShaderStages.size(); ++s)
@@ -243,21 +243,22 @@ void PipelineStateD3D11Impl::InitResourceLayouts(const PipelineStateCreateInfo&
             };
         // clang-format on
 
-        // Initialize static samplers
+        // Initialize immutable samplers
         for (Uint32 sam = 0; sam < ShaderResources.GetNumSamplers(); ++sam)
         {
-            const auto&    SamplerAttribs             = ShaderResources.GetSampler(sam);
-            constexpr bool LogStaticSamplerArrayError = true;
-            auto           SrcStaticSamplerInd        = ShaderResources.FindStaticSampler(SamplerAttribs, ResourceLayout, LogStaticSamplerArrayError);
-            if (SrcStaticSamplerInd >= 0)
+            const auto&    SamplerAttribs            = ShaderResources.GetSampler(sam);
+            constexpr bool LogImtblSamplerArrayError = true;
+            auto           SrcImtblSamplerInd        = ShaderResources.FindImmutableSampler(SamplerAttribs, ResourceLayout, LogImtblSamplerArrayError);
+            if (SrcImtblSamplerInd >= 0)
             {
-                const auto&             SrcStaticSamplerInfo = ResourceLayout.StaticSamplers[SrcStaticSamplerInd];
-                RefCntAutoPtr<ISampler> pStaticSampler;
-                GetDevice()->CreateSampler(SrcStaticSamplerInfo.Desc, &pStaticSampler);
-                StaticSamplers.emplace_back(SamplerAttribs, std::move(pStaticSampler));
+                const auto& SrcImtblSamplerInfo = ResourceLayout.ImmutableSamplers[SrcImtblSamplerInd];
+
+                RefCntAutoPtr<ISampler> pImbtlSampler;
+                GetDevice()->CreateSampler(SrcImtblSamplerInfo.Desc, &pImbtlSampler);
+                ImmutableSamplers.emplace_back(SamplerAttribs, std::move(pImbtlSampler));
             }
         }
-        m_StaticSamplerOffsets[s + 1] = static_cast<Uint16>(StaticSamplers.size());
+        m_ImmutableSamplerOffsets[s + 1] = static_cast<Uint16>(ImmutableSamplers.size());
 
         if (m_Desc.SRBAllocationGranularity > 1)
         {
@@ -279,14 +280,14 @@ void PipelineStateD3D11Impl::InitResourceLayouts(const PipelineStateCreateInfo&
         m_SRBMemAllocator.Initialize(m_Desc.SRBAllocationGranularity, GetNumShaderStages(), ShaderResLayoutDataSizes.data(), GetNumShaderStages(), ShaderResCacheDataSizes.data());
     }
 
-    m_StaticSamplers.reserve(StaticSamplers.size());
-    for (auto& Sam : StaticSamplers)
-        m_StaticSamplers.emplace_back(std::move(Sam));
+    m_ImmutableSamplers.reserve(ImmutableSamplers.size());
+    for (auto& ImtblSam : ImmutableSamplers)
+        m_ImmutableSamplers.emplace_back(std::move(ImtblSam));
 
     for (Uint32 s = 0; s < GetNumShaderStages(); ++s)
     {
-        // Initialize static samplers in the static resource cache to avoid warning messages
-        SetStaticSamplers(m_pStaticResourceCaches[s], s);
+        // Initialize immutable samplers in the static resource cache to avoid warning messages
+        SetImmutableSamplers(m_pStaticResourceCaches[s], s);
     }
 }
 
@@ -431,15 +432,15 @@ IShaderResourceVariable* PipelineStateD3D11Impl::GetStaticVariableByIndex(SHADER
     return m_pStaticResourceLayouts[LayoutInd].GetShaderVariable(Index);
 }
 
-void PipelineStateD3D11Impl::SetStaticSamplers(ShaderResourceCacheD3D11& ResourceCache, Uint32 ShaderInd) const
+void PipelineStateD3D11Impl::SetImmutableSamplers(ShaderResourceCacheD3D11& ResourceCache, Uint32 ShaderInd) const
 {
     auto NumCachedSamplers = ResourceCache.GetSamplerCount();
-    for (Uint32 s = m_StaticSamplerOffsets[ShaderInd]; s < m_StaticSamplerOffsets[ShaderInd + 1]; ++s)
+    for (Uint32 s = m_ImmutableSamplerOffsets[ShaderInd]; s < m_ImmutableSamplerOffsets[ShaderInd + 1]; ++s)
     {
-        auto&       SamplerInfo       = m_StaticSamplers[s];
+        auto&       SamplerInfo       = m_ImmutableSamplers[s];
         const auto& SamAttribs        = SamplerInfo.Attribs;
         auto*       pSamplerD3D11Impl = SamplerInfo.pSampler.RawPtr<SamplerD3D11Impl>();
-        // Limiting EndBindPoint is required when initializing static samplers in a Shader's static cache
+        // Limiting EndBindPoint is required when initializing immutable samplers in a Shader's static cache
         auto EndBindPoint = std::min(static_cast<Uint32>(SamAttribs.BindPoint) + SamAttribs.BindCount, NumCachedSamplers);
         for (Uint32 BindPoint = SamAttribs.BindPoint; BindPoint < EndBindPoint; ++BindPoint)
             ResourceCache.SetSampler(BindPoint, pSamplerD3D11Impl);
diff --git a/Graphics/GraphicsEngineD3D11/src/ShaderResourceBindingD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/ShaderResourceBindingD3D11Impl.cpp
index 88c7b77f..5e95db97 100644
--- a/Graphics/GraphicsEngineD3D11/src/ShaderResourceBindingD3D11Impl.cpp
+++ b/Graphics/GraphicsEngineD3D11/src/ShaderResourceBindingD3D11Impl.cpp
@@ -177,7 +177,7 @@ void ShaderResourceBindingD3D11Impl::InitializeStaticResources(const IPipelineSt
         }
 #endif
         StaticResLayout.CopyResources(m_pBoundResourceCaches[shader]);
-        pPSOD3D11->SetStaticSamplers(m_pBoundResourceCaches[shader], shader);
+        pPSOD3D11->SetImmutableSamplers(m_pBoundResourceCaches[shader], shader);
     }
 
     m_bIsStaticResourcesBound = true;
diff --git a/Graphics/GraphicsEngineD3D11/src/ShaderResourceLayoutD3D11.cpp b/Graphics/GraphicsEngineD3D11/src/ShaderResourceLayoutD3D11.cpp
index 723e190a..c1e6e65a 100755
--- a/Graphics/GraphicsEngineD3D11/src/ShaderResourceLayoutD3D11.cpp
+++ b/Graphics/GraphicsEngineD3D11/src/ShaderResourceLayoutD3D11.cpp
@@ -86,9 +86,9 @@ size_t ShaderResourceLayoutD3D11::GetRequiredMemorySize(const ShaderResourcesD3D
                                                         const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,

                                                         Uint32                               NumAllowedTypes)

 {

-    // Skip static samplers as they are initialized directly in the resource cache by the PSO

-    constexpr bool CountStaticSamplers = false;

-    auto           ResCounters         = SrcResources.CountResources(ResourceLayout, AllowedVarTypes, NumAllowedTypes, CountStaticSamplers);

+    // Skip immutable samplers as they are initialized directly in the resource cache by the PSO

+    constexpr bool CountImtblSamplers = false;

+    auto           ResCounters        = SrcResources.CountResources(ResourceLayout, AllowedVarTypes, NumAllowedTypes, CountImtblSamplers);

     // clang-format off

     auto MemSize = ResCounters.NumCBs      * sizeof(ConstBuffBindInfo) +

                    ResCounters.NumTexSRVs  * sizeof(TexSRVBindInfo)    +

@@ -120,9 +120,9 @@ ShaderResourceLayoutD3D11::ShaderResourceLayoutD3D11(IObject&
     const auto AllowedTypeBits = GetAllowedTypeBits(VarTypes, NumVarTypes);

 

     // Count total number of resources of allowed types

-    // Skip static samplers as they are initialized directly in the resource cache by the PSO

-    constexpr bool CountStaticSamplers = false;

-    auto           ResCounters         = m_pResources->CountResources(ResourceLayout, VarTypes, NumVarTypes, CountStaticSamplers);

+    // Skip immutable samplers as they are initialized directly in the resource cache by the PSO

+    constexpr bool CountImtblSamplers = false;

+    auto           ResCounters        = m_pResources->CountResources(ResourceLayout, VarTypes, NumVarTypes, CountImtblSamplers);

 

     // Initialize offsets

     size_t CurrentOffset = 0;

@@ -192,12 +192,12 @@ ShaderResourceLayoutD3D11::ShaderResourceLayoutD3D11(IObject&
             auto VarType = m_pResources->FindVariableType(Sampler, ResourceLayout);

             if (IsAllowedType(VarType, AllowedTypeBits))

             {

-                // Constructor of PipelineStateD3D11Impl initializes static samplers and will log the error, if any

-                constexpr bool LogStaticSamplerArrayError = false;

-                auto           StaticSamplerInd           = m_pResources->FindStaticSampler(Sampler, ResourceLayout, LogStaticSamplerArrayError);

-                if (StaticSamplerInd >= 0)

+                // Constructor of PipelineStateD3D11Impl initializes immutable samplers and will log the error, if any

+                constexpr bool LogImtblSamplerArrayError = false;

+                auto           ImtblSamplerInd           = m_pResources->FindImmutableSampler(Sampler, ResourceLayout, LogImtblSamplerArrayError);

+                if (ImtblSamplerInd >= 0)

                 {

-                    // Skip static samplers as they are initialized directly in the resource cache by the PSO

+                    // Skip immutble samplers as they are initialized directly in the resource cache by the PSO

                     return;

                 }

                 // Initialize current sampler in place, increment sampler counter

@@ -241,10 +241,10 @@ ShaderResourceLayoutD3D11::ShaderResourceLayoutD3D11(IObject&
                     AssignedSamplerIndex = TexSRVBindInfo::InvalidSamplerIndex;

 #ifdef DILIGENT_DEBUG

                     // Shader error will be logged by the PipelineStateD3D11Impl

-                    constexpr bool LogStaticSamplerArrayError = false;

-                    if (m_pResources->FindStaticSampler(AssignedSamplerAttribs, ResourceLayout, LogStaticSamplerArrayError) < 0)

+                    constexpr bool LogImtblSamplerArrayError = false;

+                    if (m_pResources->FindImmutableSampler(AssignedSamplerAttribs, ResourceLayout, LogImtblSamplerArrayError) < 0)

                     {

-                        UNEXPECTED("Unable to find non-static sampler assigned to texture SRV '", TexSRV.Name, "'.");

+                        UNEXPECTED("Unable to find non-immutable sampler assigned to texture SRV '", TexSRV.Name, "'.");

                     }

 #endif

                 }

@@ -252,10 +252,10 @@ ShaderResourceLayoutD3D11::ShaderResourceLayoutD3D11(IObject&
                 {

 #ifdef DILIGENT_DEBUG

                     // Shader error will be logged by the PipelineStateD3D11Impl

-                    constexpr bool LogStaticSamplerArrayError = false;

-                    if (m_pResources->FindStaticSampler(AssignedSamplerAttribs, ResourceLayout, LogStaticSamplerArrayError) >= 0)

+                    constexpr bool LogImtblSamplerArrayError = false;

+                    if (m_pResources->FindImmutableSampler(AssignedSamplerAttribs, ResourceLayout, LogImtblSamplerArrayError) >= 0)

                     {

-                        UNEXPECTED("Static sampler '", AssignedSamplerAttribs.Name, "' is assigned to texture SRV '", TexSRV.Name, "'.");

+                        UNEXPECTED("Immutable sampler '", AssignedSamplerAttribs.Name, "' is assigned to texture SRV '", TexSRV.Name, "'.");

                     }

 #endif

                 }

@@ -412,7 +412,7 @@ void ShaderResourceLayoutD3D11::CopyResources(ShaderResourceCacheD3D11& DstCache
 

         [&](const SamplerBindInfo& sam) //

         {

-            //VERIFY(!sam.IsStaticSampler, "Variables are not created for static samplers");

+            //VERIFY(!sam.IsImmutableSampler, "Variables are not created for immutable samplers");

             for (auto SamSlot = sam.m_Attribs.BindPoint; SamSlot < sam.m_Attribs.BindPoint + sam.m_Attribs.BindCount; ++SamSlot)

             {

                 VERIFY_EXPR(SamSlot < m_ResourceCache.GetSamplerCount() && SamSlot < DstCache.GetSamplerCount());

@@ -460,7 +460,7 @@ void ShaderResourceLayoutD3D11::TexSRVBindInfo::BindResource(IDeviceObject* pVie
     if (ValidSamplerAssigned())

     {

         auto& Sampler = m_ParentResLayout.GetResource<SamplerBindInfo>(SamplerIndex);

-        //VERIFY(!Sampler.IsStaticSampler, "Static samplers are not assigned to texture SRVs as they are initialized directly in the shader resource cache");

+        //VERIFY(!Sampler.IsImmutableSampler, "Immutable samplers are not assigned to texture SRVs as they are initialized directly in the shader resource cache");

         VERIFY_EXPR(Sampler.m_Attribs.BindCount == m_Attribs.BindCount || Sampler.m_Attribs.BindCount == 1);

         auto SamplerBindPoint = Sampler.m_Attribs.BindPoint + (Sampler.m_Attribs.BindCount != 1 ? ArrayIndex : 0);

 

@@ -502,7 +502,7 @@ void ShaderResourceLayoutD3D11::SamplerBindInfo::BindResource(IDeviceObject* pSa
                   "Array index (", ArrayIndex, ") is out of range for variable '", m_Attribs.Name,

                   "'. Max allowed index: ", m_Attribs.BindCount - 1);

     auto& ResourceCache = m_ParentResLayout.m_ResourceCache;

-    //VERIFY(!IsStaticSampler, "Cannot bind sampler to a static sampler");

+    //VERIFY(!IsImmutableSampler, "Cannot bind sampler to an immutable sampler");

 

     // We cannot use ValidatedCast<> here as the resource retrieved from the

     // resource mapping can be of wrong type

@@ -737,7 +737,7 @@ IShaderResourceVariable* ShaderResourceLayoutD3D11::GetShaderVariable(const Char
 

     if (!m_pResources->IsUsingCombinedTextureSamplers())

     {

-        // Static samplers are never created in the resource layout

+        // Immutable samplers are never created in the resource layout

         if (auto* pSampler = GetResourceByName<SamplerBindInfo>(Name))

             return pSampler;

     }

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/src/D3D12TypeConversions.cpp b/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
index 23652519..34a98a45 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/PipelineStateD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
index f04a309e..b65ad4fc 100644
--- a/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
@@ -117,7 +117,7 @@ LinearAllocator PipelineStateD3D12Impl::InitInternalObjects(const PSOCreateInfoT
 
     MemPool.Reserve();
 
-    m_RootSig.AllocateStaticSamplers(CreateInfo.PSODesc.ResourceLayout);
+    m_RootSig.AllocateImmutableSamplers(CreateInfo.PSODesc.ResourceLayout);
 
     m_pShaderResourceLayouts = MemPool.Allocate<ShaderResourceLayoutD3D12>(GetNumShaderStages() * 2);
     m_pStaticResourceCaches  = MemPool.Allocate<ShaderResourceCacheD3D12>(GetNumShaderStages());
@@ -417,7 +417,7 @@ void PipelineStateD3D12Impl::InitResourceLayouts(const PipelineStateCreateInfo&
         }
         ShaderResources::DvpVerifyResourceLayout(ResourceLayout, pResources, GetNumShaderStages(),
                                                  (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES) == 0,
-                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_STATIC_SAMPLERS) == 0);
+                                                 (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_IMMUTABLE_SAMPLERS) == 0);
     }
 #endif
 
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/ShaderResourceLayoutD3D12.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
index c0029da5..06e902fb 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
@@ -149,10 +149,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];
             }
         },
@@ -237,7 +238,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]++);
@@ -258,12 +259,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
                 {
@@ -290,18 +292,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
                     }
@@ -619,7 +622,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;
 
@@ -793,7 +796,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);
@@ -920,7 +923,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/GraphicsEngineD3DBase/include/ShaderResources.hpp b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.hpp
index 2843f9f0..f15d2e74 100644
--- a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.hpp
+++ b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.hpp
@@ -372,20 +372,20 @@ public:
     SHADER_RESOURCE_VARIABLE_TYPE FindVariableType(const D3DShaderResourceAttribs&   ResourceAttribs,
                                                    const PipelineResourceLayoutDesc& ResourceLayout) const;
 
-    Int32 FindStaticSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
-                            const PipelineResourceLayoutDesc& ResourceLayoutDesc,
-                            bool                              LogStaticSamplerArrayError) const;
+    Int32 FindImmutableSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
+                               const PipelineResourceLayoutDesc& ResourceLayoutDesc,
+                               bool                              LogImmutableSamplerArrayError) const;
 
     D3DShaderResourceCounters CountResources(const PipelineResourceLayoutDesc&    ResourceLayout,
                                              const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
                                              Uint32                               NumAllowedTypes,
-                                             bool                                 CountStaticSamplers) const noexcept;
+                                             bool                                 CountImmutableSamplers) const noexcept;
 #ifdef DILIGENT_DEVELOPMENT
     static void DvpVerifyResourceLayout(const PipelineResourceLayoutDesc& ResourceLayout,
                                         const ShaderResources* const      pShaderResources[],
                                         Uint32                            NumShaders,
                                         bool                              VerifyVariables,
-                                        bool                              VerifyStaticSamplers);
+                                        bool                              VerifyImmutableSamplers);
 #endif
 
     void GetShaderModel(Uint32& Major, Uint32& Minor) const
diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
index 498e31a2..86a7fc35 100644
--- a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
+++ b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
@@ -122,44 +122,44 @@ SHADER_RESOURCE_VARIABLE_TYPE ShaderResources::FindVariableType(const D3DShaderR
     }
 }
 
-Int32 ShaderResources::FindStaticSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
-                                         const PipelineResourceLayoutDesc& ResourceLayoutDesc,
-                                         bool                              LogStaticSamplerArrayError) const
+Int32 ShaderResources::FindImmutableSampler(const D3DShaderResourceAttribs&   ResourceAttribs,
+                                            const PipelineResourceLayoutDesc& ResourceLayoutDesc,
+                                            bool                              LogImmutableSamplerArrayError) const
 {
     VERIFY(ResourceAttribs.GetInputType() == D3D_SIT_SAMPLER, "Sampler is expected");
 
-    auto StaticSamplerInd =
-        Diligent::FindStaticSampler(ResourceLayoutDesc.StaticSamplers,
-                                    ResourceLayoutDesc.NumStaticSamplers,
-                                    m_ShaderType,
-                                    ResourceAttribs.Name,
-                                    m_SamplerSuffix);
+    auto ImtblSamplerInd =
+        Diligent::FindImmutableSampler(ResourceLayoutDesc.ImmutableSamplers,
+                                       ResourceLayoutDesc.NumImmutableSamplers,
+                                       m_ShaderType,
+                                       ResourceAttribs.Name,
+                                       m_SamplerSuffix);
 
-    if (StaticSamplerInd >= 0 && ResourceAttribs.BindCount > 1)
+    if (ImtblSamplerInd >= 0 && ResourceAttribs.BindCount > 1)
     {
         Uint32 ShaderMajorVersion = 0;
         Uint32 ShaderMinorVersion = 0;
         GetShaderModel(ShaderMajorVersion, ShaderMinorVersion);
         if (ShaderMajorVersion >= 6 || ShaderMajorVersion >= 5 && ShaderMinorVersion >= 1)
         {
-            if (LogStaticSamplerArrayError)
+            if (LogImmutableSamplerArrayError)
             {
-                LOG_ERROR_MESSAGE("Static sampler '", ResourceAttribs.Name, '[', ResourceAttribs.BindCount,
+                LOG_ERROR_MESSAGE("Immutable 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;
+            ImtblSamplerInd = -1;
         }
     }
 
-    return StaticSamplerInd;
+    return ImtblSamplerInd;
 }
 
 
 D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResourceLayoutDesc&    ResourceLayout,
                                                           const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes,
                                                           Uint32                               NumAllowedTypes,
-                                                          bool                                 CountStaticSamplers) const noexcept
+                                                          bool                                 CountImmutableSamplers) const noexcept
 {
     auto AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes);
 
@@ -176,11 +176,11 @@ D3DShaderResourceCounters ShaderResources::CountResources(const PipelineResource
             auto VarType = FindVariableType(Sam, ResourceLayout);
             if (IsAllowedType(VarType, AllowedTypeBits))
             {
-                if (!CountStaticSamplers)
+                if (!CountImmutableSamplers)
                 {
-                    constexpr bool LogStaticSamplerArrayError = false;
-                    if (FindStaticSampler(Sam, ResourceLayout, LogStaticSamplerArrayError) >= 0)
-                        return; // Skip static sampler if requested
+                    constexpr bool LogImtblSamplerArrayError = false;
+                    if (FindImmutableSampler(Sam, ResourceLayout, LogImtblSamplerArrayError) >= 0)
+                        return; // Skip immutable sampler if requested
                 }
                 ++Counters.NumSamplers;
             }
@@ -219,7 +219,7 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
                                               const ShaderResources* const      pShaderResources[],
                                               Uint32                            NumShaders,
                                               bool                              VerifyVariables,
-                                              bool                              VerifyStaticSamplers)
+                                              bool                              VerifyImmutableSamplers)
 {
     auto GetAllowedShadersString = [&](SHADER_TYPE ShaderStages) //
     {
@@ -300,40 +300,40 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
         }
     }
 
-    if (VerifyStaticSamplers)
+    if (VerifyImmutableSamplers)
     {
-        for (Uint32 sam = 0; sam < ResourceLayout.NumStaticSamplers; ++sam)
+        for (Uint32 sam = 0; sam < ResourceLayout.NumImmutableSamplers; ++sam)
         {
-            const auto& StSamDesc = ResourceLayout.StaticSamplers[sam];
+            const auto& StSamDesc = ResourceLayout.ImmutableSamplers[sam];
             if (StSamDesc.ShaderStages == SHADER_TYPE_UNKNOWN)
             {
-                LOG_WARNING_MESSAGE("No allowed shader stages are specified for static sampler '", StSamDesc.SamplerOrTextureName, "'.");
+                LOG_WARNING_MESSAGE("No allowed shader stages are specified for immutable sampler '", StSamDesc.SamplerOrTextureName, "'.");
                 continue;
             }
 
             const auto* TexOrSamName = StSamDesc.SamplerOrTextureName;
 
-            bool StaticSamplerFound = false;
-            for (Uint32 s = 0; s < NumShaders && !StaticSamplerFound; ++s)
+            bool ImtblSamplerFound = false;
+            for (Uint32 s = 0; s < NumShaders && !ImtblSamplerFound; ++s)
             {
                 const auto& Resources = *pShaderResources[s];
                 if ((StSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
                     continue;
 
-                // Look for static sampler.
+                // Look for immutable 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() && !ImtblSamplerFound; ++n)
                 {
                     const auto& Sampler = Resources.GetSampler(n);
-                    StaticSamplerFound  = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
+                    ImtblSamplerFound   = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
                 }
             }
 
-            if (!StaticSamplerFound)
+            if (!ImtblSamplerFound)
             {
-                LOG_WARNING_MESSAGE("Static sampler '", TexOrSamName, "' is not found in any of the designated shader stages: ",
+                LOG_WARNING_MESSAGE("Immutable sampler '", TexOrSamName, "' is not found in any of the designated shader stages: ",
                                     GetAllowedShadersString(StSamDesc.ShaderStages));
             }
         }
diff --git a/Graphics/GraphicsEngineOpenGL/include/GLPipelineResourceLayout.hpp b/Graphics/GraphicsEngineOpenGL/include/GLPipelineResourceLayout.hpp
index 80f622c9..24e88004 100644
--- a/Graphics/GraphicsEngineOpenGL/include/GLPipelineResourceLayout.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/GLPipelineResourceLayout.hpp
@@ -118,15 +118,15 @@ public:
         GLVariableBase(const GLProgramResources::GLResourceAttribs& ResourceAttribs,
                        GLPipelineResourceLayout&                    ParentLayout,
                        SHADER_RESOURCE_VARIABLE_TYPE                VariableType,
-                       Int32                                        StaticSamplerIdx) :
+                       Int32                                        ImtblSamplerIdx) :
             // clang-format off
             TBase             {ParentLayout},
             m_Attribs         {ResourceAttribs },
             m_VariableType    {VariableType    },
-            m_StaticSamplerIdx{StaticSamplerIdx}
+            m_ImtblSamplerIdx {ImtblSamplerIdx}
         // clang-format on
         {
-            VERIFY_EXPR(StaticSamplerIdx < 0 || ResourceAttribs.ResourceType == SHADER_RESOURCE_TYPE_TEXTURE_SRV);
+            VERIFY_EXPR(ImtblSamplerIdx < 0 || ResourceAttribs.ResourceType == SHADER_RESOURCE_TYPE_TEXTURE_SRV);
         }
 
         virtual SHADER_RESOURCE_VARIABLE_TYPE DILIGENT_CALL_TYPE GetType() const override final
@@ -146,7 +146,7 @@ public:
 
         const GLProgramResources::GLResourceAttribs& m_Attribs;
         const SHADER_RESOURCE_VARIABLE_TYPE          m_VariableType;
-        const Int32                                  m_StaticSamplerIdx;
+        const Int32                                  m_ImtblSamplerIdx;
     };
 
 
@@ -188,8 +188,8 @@ public:
         SamplerBindInfo(const GLProgramResources::GLResourceAttribs& ResourceAttribs,
                         GLPipelineResourceLayout&                    ParentResLayout,
                         SHADER_RESOURCE_VARIABLE_TYPE                VariableType,
-                        Int32                                        StaticSamplerIdx) :
-            GLVariableBase{ResourceAttribs, ParentResLayout, VariableType, StaticSamplerIdx}
+                        Int32                                        ImtblSamplerIdx) :
+            GLVariableBase{ResourceAttribs, ParentResLayout, VariableType, ImtblSamplerIdx}
         {}
 
         // Non-virtual function
diff --git a/Graphics/GraphicsEngineOpenGL/include/GLProgramResourceCache.hpp b/Graphics/GraphicsEngineOpenGL/include/GLProgramResourceCache.hpp
index 3fbc550e..eab96f6a 100644
--- a/Graphics/GraphicsEngineOpenGL/include/GLProgramResourceCache.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/GLProgramResourceCache.hpp
@@ -128,9 +128,9 @@ public:
         GetSampler(Binding).Set(std::move(pTexView), SetSampler);
     }
 
-    void SetStaticSampler(Uint32 Binding, ISampler* pStaticSampler)
+    void SetImmutableSampler(Uint32 Binding, ISampler* pImtblSampler)
     {
-        GetSampler(Binding).pSampler = ValidatedCast<SamplerGLImpl>(pStaticSampler);
+        GetSampler(Binding).pSampler = ValidatedCast<SamplerGLImpl>(pImtblSampler);
     }
 
     void CopySampler(Uint32 Binding, const CachedResourceView& SrcSam)
diff --git a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
index 83f8bdad..0c5692d0 100644
--- a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
@@ -95,7 +95,7 @@ public:
 private:
     GLObjectWrappers::GLPipelineObj& GetGLProgramPipeline(GLContext::NativeGLContextType Context);
 
-    void InitStaticSamplersInResourceCache(const GLPipelineResourceLayout& ResourceLayout, GLProgramResourceCache& Cache) const;
+    void InitImmutableSamplersInResourceCache(const GLPipelineResourceLayout& ResourceLayout, GLProgramResourceCache& Cache) const;
 
     struct GLPipelineShaderStageInfo
     {
@@ -143,8 +143,8 @@ private:
     Uint32 m_TotalImageBindings         = 0;
     Uint32 m_TotalStorageBufferBindings = 0;
 
-    using SamplerPtr             = RefCntAutoPtr<ISampler>;
-    SamplerPtr* m_StaticSamplers = nullptr; // [m_Desc.ResourceLayout.NumStaticSamplers]
+    using SamplerPtr                = RefCntAutoPtr<ISampler>;
+    SamplerPtr* m_ImmutableSamplers = nullptr; // [m_Desc.ResourceLayout.NumImmutableSamplers]
 };
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineOpenGL/src/GLPipelineResourceLayout.cpp b/Graphics/GraphicsEngineOpenGL/src/GLPipelineResourceLayout.cpp
index 04a08af1..d2f9cddc 100644
--- a/Graphics/GraphicsEngineOpenGL/src/GLPipelineResourceLayout.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/GLPipelineResourceLayout.cpp
@@ -147,11 +147,11 @@ void GLPipelineResourceLayout::Initialize(GLProgramResources*                  P
             {
                 auto VarType = GetShaderVariableType(ShaderStages, Sam.Name, ResourceLayout);
                 VERIFY_EXPR(IsAllowedType(VarType, DbgAllowedTypeBits));
-                Int32 StaticSamplerIdx = -1;
+                Int32 ImtblSamplerIdx = -1;
                 if (Sam.ResourceType == SHADER_RESOURCE_TYPE_TEXTURE_SRV)
                 {
-                    StaticSamplerIdx = FindStaticSampler(ResourceLayout.StaticSamplers, ResourceLayout.NumStaticSamplers, ShaderStages,
-                                                         Sam.Name, nullptr);
+                    ImtblSamplerIdx = FindImmutableSampler(ResourceLayout.ImmutableSamplers, ResourceLayout.NumImmutableSamplers, ShaderStages,
+                                                           Sam.Name, nullptr);
                 }
                 auto* pSamVar = new (&GetResource<SamplerBindInfo>(VarCounters.NumSamplers++))
                     SamplerBindInfo //
@@ -159,7 +159,7 @@ void GLPipelineResourceLayout::Initialize(GLProgramResources*                  P
                         Sam,
                         *this,
                         VarType,
-                        StaticSamplerIdx //
+                        ImtblSamplerIdx //
                     };
                 SamplerBindingSlots = std::max(SamplerBindingSlots, pSamVar->m_Attribs.Binding + pSamVar->m_Attribs.ArraySize);
             },
@@ -290,13 +290,13 @@ void GLPipelineResourceLayout::SamplerBindInfo::BindResource(IDeviceObject* pVie
         {
             auto& CachedTexSampler = ResourceCache.GetConstSampler(m_Attribs.Binding + ArrayIndex);
             VerifyResourceViewBinding(m_Attribs, GetType(), ArrayIndex, pView, pViewGL.RawPtr(), {TEXTURE_VIEW_SHADER_RESOURCE}, CachedTexSampler.pView.RawPtr());
-            if (m_StaticSamplerIdx >= 0)
+            if (m_ImtblSamplerIdx >= 0)
             {
-                VERIFY(CachedTexSampler.pSampler != nullptr, "Static samplers must be initialized by PipelineStateGLImpl::InitializeSRBResourceCache!");
+                VERIFY(CachedTexSampler.pSampler != nullptr, "Immutable samplers must be initialized by PipelineStateGLImpl::InitializeSRBResourceCache!");
             }
         }
 #endif
-        ResourceCache.SetTexSampler(m_Attribs.Binding + ArrayIndex, std::move(pViewGL), m_StaticSamplerIdx < 0);
+        ResourceCache.SetTexSampler(m_Attribs.Binding + ArrayIndex, std::move(pViewGL), m_ImtblSamplerIdx < 0);
     }
     else if (m_Attribs.ResourceType == SHADER_RESOURCE_TYPE_BUFFER_SRV)
     {
@@ -794,9 +794,9 @@ bool GLPipelineResourceLayout::dvpVerifyBindings(const GLProgramResourceCache& R
                 else
                 {
                     const auto& CachedSampler = ResourceCache.GetConstSampler(BindPoint);
-                    if (sam.m_StaticSamplerIdx >= 0 && CachedSampler.pSampler == nullptr)
+                    if (sam.m_ImtblSamplerIdx >= 0 && CachedSampler.pSampler == nullptr)
                     {
-                        LOG_ERROR_MESSAGE("Static sampler is not initialized for texture '", sam.m_Attribs.Name, "'");
+                        LOG_ERROR_MESSAGE("Immutable sampler is not initialized for texture '", sam.m_Attribs.Name, "'");
                         BindingsOK = false;
                     }
                 }
diff --git a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
index 7b7d4e21..8bc3802e 100644
--- a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
@@ -45,7 +45,7 @@ void PipelineStateGLImpl::Initialize(const PSOCreateInfoType& CreateInfo, const
 
     MemPool.AddSpace<GLProgramObj>(GetNumShaderStages());
     MemPool.AddSpace<GLProgramResources>(GetNumShaderStages());
-    MemPool.AddSpace<SamplerPtr>(m_Desc.ResourceLayout.NumStaticSamplers);
+    MemPool.AddSpace<SamplerPtr>(m_Desc.ResourceLayout.NumImmutableSamplers);
 
     ReserveSpaceForPipelineDesc(CreateInfo, MemPool);
 
@@ -129,9 +129,9 @@ PipelineStateGLImpl::~PipelineStateGLImpl()
         m_GLPrograms[i].~GLProgramObj();
         m_ProgramResources[i].~GLProgramResources();
     }
-    for (Uint32 i = 0; i < m_Desc.ResourceLayout.NumStaticSamplers; ++i)
+    for (Uint32 i = 0; i < m_Desc.ResourceLayout.NumImmutableSamplers; ++i)
     {
-        m_StaticSamplers[i].~SamplerPtr();
+        m_ImmutableSamplers[i].~SamplerPtr();
     }
 
     void* pRawMem = m_GLPrograms;
@@ -207,17 +207,17 @@ void PipelineStateGLImpl::InitResourceLayouts(const std::vector<GLPipelineShader
         m_ResourceLayout.Initialize(m_ProgramResources, static_cast<Uint32>(ShaderStages.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, nullptr, 0, nullptr);
     }
 
-    m_StaticSamplers = MemPool.ConstructArray<SamplerPtr>(m_Desc.ResourceLayout.NumStaticSamplers);
-    for (Uint32 s = 0; s < m_Desc.ResourceLayout.NumStaticSamplers; ++s)
+    m_ImmutableSamplers = MemPool.ConstructArray<SamplerPtr>(m_Desc.ResourceLayout.NumImmutableSamplers);
+    for (Uint32 s = 0; s < m_Desc.ResourceLayout.NumImmutableSamplers; ++s)
     {
-        pDeviceGL->CreateSampler(m_Desc.ResourceLayout.StaticSamplers[s].Desc, &m_StaticSamplers[s]);
+        pDeviceGL->CreateSampler(m_Desc.ResourceLayout.ImmutableSamplers[s].Desc, &m_ImmutableSamplers[s]);
     }
 
     {
         // Clone only static variables into static resource layout, assign and initialize static resource cache
         const SHADER_RESOURCE_VARIABLE_TYPE StaticVars[] = {SHADER_RESOURCE_VARIABLE_TYPE_STATIC};
         m_StaticResourceLayout.Initialize(m_ProgramResources, static_cast<Uint32>(ShaderStages.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, StaticVars, _countof(StaticVars), &m_StaticResourceCache);
-        InitStaticSamplersInResourceCache(m_StaticResourceLayout, m_StaticResourceCache);
+        InitImmutableSamplersInResourceCache(m_StaticResourceLayout, m_StaticResourceCache);
     }
 }
 
@@ -303,19 +303,19 @@ GLObjectWrappers::GLPipelineObj& PipelineStateGLImpl::GetGLProgramPipeline(GLCon
 void PipelineStateGLImpl::InitializeSRBResourceCache(GLProgramResourceCache& ResourceCache) const
 {
     ResourceCache.Initialize(m_TotalUniformBufferBindings, m_TotalSamplerBindings, m_TotalImageBindings, m_TotalStorageBufferBindings, GetRawAllocator());
-    InitStaticSamplersInResourceCache(m_ResourceLayout, ResourceCache);
+    InitImmutableSamplersInResourceCache(m_ResourceLayout, ResourceCache);
 }
 
-void PipelineStateGLImpl::InitStaticSamplersInResourceCache(const GLPipelineResourceLayout& ResourceLayout, GLProgramResourceCache& Cache) const
+void PipelineStateGLImpl::InitImmutableSamplersInResourceCache(const GLPipelineResourceLayout& ResourceLayout, GLProgramResourceCache& Cache) const
 {
     for (Uint32 s = 0; s < ResourceLayout.GetNumResources<GLPipelineResourceLayout::SamplerBindInfo>(); ++s)
     {
         const auto& Sam = ResourceLayout.GetConstResource<GLPipelineResourceLayout::SamplerBindInfo>(s);
-        if (Sam.m_StaticSamplerIdx >= 0)
+        if (Sam.m_ImtblSamplerIdx >= 0)
         {
-            ISampler* pSampler = m_StaticSamplers[Sam.m_StaticSamplerIdx].RawPtr<ISampler>();
+            ISampler* pSampler = m_ImmutableSamplers[Sam.m_ImtblSamplerIdx].RawPtr<ISampler>();
             for (Uint32 binding = Sam.m_Attribs.Binding; binding < Sam.m_Attribs.Binding + Sam.m_Attribs.ArraySize; ++binding)
-                Cache.SetStaticSampler(binding, pSampler);
+                Cache.SetImmutableSampler(binding, pSampler);
         }
     }
 }
diff --git a/Graphics/GraphicsEngineVulkan/include/ShaderResourceLayoutVk.hpp b/Graphics/GraphicsEngineVulkan/include/ShaderResourceLayoutVk.hpp
index 62ff38b5..0013fe23 100644
--- a/Graphics/GraphicsEngineVulkan/include/ShaderResourceLayoutVk.hpp
+++ b/Graphics/GraphicsEngineVulkan/include/ShaderResourceLayoutVk.hpp
@@ -158,7 +158,7 @@ public:
                            const PipelineResourceLayoutDesc& ResourceLayoutDesc,
                            class PipelineLayout&             PipelineLayout,
                            bool                              VerifyVariables,
-                           bool                              VerifyStaticSamplers);
+                           bool                              VerifyImmutableSamplers);
 
     // sizeof(VkResource) == 24 (x64)
     struct VkResource
@@ -293,7 +293,7 @@ public:
     static void dvpVerifyResourceLayoutDesc(const TShaderStages&              ShaderStages,
                                             const PipelineResourceLayoutDesc& ResourceLayoutDesc,
                                             bool                              VerifyVariables,
-                                            bool                              VerifyStaticSamplers);
+                                            bool                              VerifyImmutableSamplers);
 #endif
 
     Uint32 GetResourceCount(SHADER_RESOURCE_VARIABLE_TYPE VarType) const
diff --git a/Graphics/GraphicsEngineVulkan/src/GenerateMipsVkHelper.cpp b/Graphics/GraphicsEngineVulkan/src/GenerateMipsVkHelper.cpp
index d6f4b0be..e7ab95b1 100644
--- a/Graphics/GraphicsEngineVulkan/src/GenerateMipsVkHelper.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/GenerateMipsVkHelper.cpp
@@ -166,9 +166,9 @@ std::array<RefCntAutoPtr<IPipelineState>, 4> GenerateMipsVkHelper::CreatePSOs(TE
         PSODesc.ResourceLayout.Variables    = &VarDesc;
         PSODesc.ResourceLayout.NumVariables = 1;
 
-        const StaticSamplerDesc StaticSampler(SHADER_TYPE_COMPUTE, "SrcMip", Sam_LinearClamp);
-        PSODesc.ResourceLayout.StaticSamplers    = &StaticSampler;
-        PSODesc.ResourceLayout.NumStaticSamplers = 1;
+        const ImmutableSamplerDesc ImtblSampler{SHADER_TYPE_COMPUTE, "SrcMip", Sam_LinearClamp};
+        PSODesc.ResourceLayout.ImmutableSamplers    = &ImtblSampler;
+        PSODesc.ResourceLayout.NumImmutableSamplers = 1;
 
         m_DeviceVkImpl.CreateComputePipelineState(PSOCreateInfo, &PSOs[NonPowOfTwo]);
         PSOs[NonPowOfTwo]->GetStaticVariableByName(SHADER_TYPE_COMPUTE, "CB")->Set(m_ConstantsCB);
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineLayout.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineLayout.cpp
index 6ed84171..b221659a 100644
--- a/Graphics/GraphicsEngineVulkan/src/PipelineLayout.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/PipelineLayout.cpp
@@ -213,7 +213,7 @@ bool PipelineLayout::DescriptorSetLayoutManager::DescriptorSetLayout::operator==
         if ((B0.pImmutableSamplers != nullptr && B1.pImmutableSamplers == nullptr) ||
             (B0.pImmutableSamplers == nullptr && B1.pImmutableSamplers != nullptr))
             return false;
-        // Static samplers themselves should not affect compatibility
+        // Immutable samplers themselves should not affect compatibility
         // clang-format on
     }
     return true;
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
index dfa270cc..6cbe5da9 100644
--- a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
@@ -426,7 +426,7 @@ void PipelineStateVkImpl::InitResourceLayouts(const PipelineStateCreateInfo& Cre
     ShaderResourceLayoutVk::Initialize(pDeviceVk, ShaderStages, m_ShaderResourceLayouts, GetRawAllocator(),
                                        m_Desc.ResourceLayout, m_PipelineLayout,
                                        (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_VARIABLES) == 0,
-                                       (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_STATIC_SAMPLERS) == 0);
+                                       (CreateInfo.Flags & PSO_CREATE_FLAG_IGNORE_MISSING_IMMUTABLE_SAMPLERS) == 0);
     m_PipelineLayout.Finalize(LogicalDevice);
 
     if (m_Desc.SRBAllocationGranularity > 1)
diff --git a/Graphics/GraphicsEngineVulkan/src/ShaderResourceLayoutVk.cpp b/Graphics/GraphicsEngineVulkan/src/ShaderResourceLayoutVk.cpp
index 33e0aa82..e73ee9aa 100644
--- a/Graphics/GraphicsEngineVulkan/src/ShaderResourceLayoutVk.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/ShaderResourceLayoutVk.cpp
@@ -63,10 +63,10 @@ static Int32 FindImmutableSampler(SHADER_TYPE                       ShaderType,
         return -1;
     }
 
-    for (Uint32 s = 0; s < ResourceLayoutDesc.NumStaticSamplers; ++s)
+    for (Uint32 s = 0; s < ResourceLayoutDesc.NumImmutableSamplers; ++s)
     {
-        const auto& StSam = ResourceLayoutDesc.StaticSamplers[s];
-        if (((StSam.ShaderStages & ShaderType) != 0) && StreqSuff(Attribs.Name, StSam.SamplerOrTextureName, SamplerSuffix))
+        const auto& ImtblSam = ResourceLayoutDesc.ImmutableSamplers[s];
+        if (((ImtblSam.ShaderStages & ShaderType) != 0) && StreqSuff(Attribs.Name, ImtblSam.SamplerOrTextureName, SamplerSuffix))
             return s;
     }
 
@@ -154,10 +154,10 @@ void ShaderResourceLayoutVk::AllocateMemory(const ShaderVkImpl*
     m_NumImmutableSamplers = 0;
     if (AllocateImmutableSamplers)
     {
-        for (Uint32 s = 0; s < ResourceLayoutDesc.NumStaticSamplers; ++s)
+        for (Uint32 s = 0; s < ResourceLayoutDesc.NumImmutableSamplers; ++s)
         {
-            const auto& StSamDesc = ResourceLayoutDesc.StaticSamplers[s];
-            if ((StSamDesc.ShaderStages & ShaderType) != 0)
+            const auto& ImtblSamDesc = ResourceLayoutDesc.ImmutableSamplers[s];
+            if ((ImtblSamDesc.ShaderStages & ShaderType) != 0)
                 ++m_NumImmutableSamplers;
         }
     }
@@ -286,7 +286,7 @@ void ShaderResourceLayoutVk::InitializeStaticResourceLayout(const ShaderVkImpl*
 void ShaderResourceLayoutVk::dvpVerifyResourceLayoutDesc(const TShaderStages&              ShaderStages,
                                                          const PipelineResourceLayoutDesc& ResourceLayoutDesc,
                                                          bool                              VerifyVariables,
-                                                         bool                              VerifyStaticSamplers)
+                                                         bool                              VerifyImmutableSamplers)
 {
     auto GetAllowedShadersString = [&](SHADER_TYPE Stages) //
     {
@@ -359,14 +359,14 @@ void ShaderResourceLayoutVk::dvpVerifyResourceLayoutDesc(const TShaderStages&
         }
     }
 
-    if (VerifyStaticSamplers)
+    if (VerifyImmutableSamplers)
     {
-        for (Uint32 sam = 0; sam < ResourceLayoutDesc.NumStaticSamplers; ++sam)
+        for (Uint32 sam = 0; sam < ResourceLayoutDesc.NumImmutableSamplers; ++sam)
         {
-            const auto& StSamDesc = ResourceLayoutDesc.StaticSamplers[sam];
-            if (StSamDesc.ShaderStages == SHADER_TYPE_UNKNOWN)
+            const auto& ImtblSamDesc = ResourceLayoutDesc.ImmutableSamplers[sam];
+            if (ImtblSamDesc.ShaderStages == SHADER_TYPE_UNKNOWN)
             {
-                LOG_WARNING_MESSAGE("No allowed shader stages are specified for static sampler '", StSamDesc.SamplerOrTextureName, "'.");
+                LOG_WARNING_MESSAGE("No allowed shader stages are specified for immutable sampler '", ImtblSamDesc.SamplerOrTextureName, "'.");
                 continue;
             }
 
@@ -374,36 +374,36 @@ void ShaderResourceLayoutVk::dvpVerifyResourceLayoutDesc(const TShaderStages&
             for (size_t s = 0; s < ShaderStages.size() && !SamplerFound; ++s)
             {
                 const auto& Resources = *ShaderStages[s].pShader->GetShaderResources();
-                if ((StSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
+                if ((ImtblSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
                     continue;
 
                 // Irrespective of whether HLSL-style combined image samplers are used,
-                // a static sampler can be assigned to GLSL sampled image (i.e. sampler2D g_tex)
+                // an immutable sampler can be assigned to a GLSL sampled image (i.e. sampler2D g_tex)
                 for (Uint32 i = 0; i < Resources.GetNumSmpldImgs() && !SamplerFound; ++i)
                 {
                     const auto& SmplImg = Resources.GetSmpldImg(i);
-                    SamplerFound        = (strcmp(SmplImg.Name, StSamDesc.SamplerOrTextureName) == 0);
+                    SamplerFound        = (strcmp(SmplImg.Name, ImtblSamDesc.SamplerOrTextureName) == 0);
                 }
 
                 if (!SamplerFound)
                 {
-                    // Check if static sampler is assigned to a separate sampler.
+                    // Check if an immutable sampler is assigned to a separate sampler.
                     // In case HLSL-style combined image samplers are used, the condition is  SepSmpl.Name == "g_Texture" + "_sampler".
                     // Otherwise the condition is  SepSmpl.Name == "g_Texture_sampler" + "".
                     const auto* CombinedSamplerSuffix = Resources.GetCombinedSamplerSuffix();
                     for (Uint32 i = 0; i < Resources.GetNumSepSmplrs() && !SamplerFound; ++i)
                     {
                         const auto& SepSmpl = Resources.GetSepSmplr(i);
-                        SamplerFound        = StreqSuff(SepSmpl.Name, StSamDesc.SamplerOrTextureName, CombinedSamplerSuffix);
+                        SamplerFound        = StreqSuff(SepSmpl.Name, ImtblSamDesc.SamplerOrTextureName, CombinedSamplerSuffix);
                     }
                 }
             }
 
             if (!SamplerFound)
             {
-                LOG_WARNING_MESSAGE("Static sampler '", StSamDesc.SamplerOrTextureName,
+                LOG_WARNING_MESSAGE("Immutable sampler '", ImtblSamDesc.SamplerOrTextureName,
                                     "' is not found in any of the designated shader stages: ",
-                                    GetAllowedShadersString(StSamDesc.ShaderStages));
+                                    GetAllowedShadersString(ImtblSamDesc.ShaderStages));
             }
         }
     }
@@ -417,10 +417,10 @@ void ShaderResourceLayoutVk::Initialize(IRenderDevice*                    pRende
                                         const PipelineResourceLayoutDesc& ResourceLayoutDesc,
                                         class PipelineLayout&             PipelineLayout,
                                         bool                              VerifyVariables,
-                                        bool                              VerifyStaticSamplers)
+                                        bool                              VerifyImmutableSamplers)
 {
 #ifdef DILIGENT_DEVELOPMENT
-    dvpVerifyResourceLayoutDesc(ShaderStages, ResourceLayoutDesc, VerifyVariables, VerifyStaticSamplers);
+    dvpVerifyResourceLayoutDesc(ShaderStages, ResourceLayoutDesc, VerifyVariables, VerifyImmutableSamplers);
 #endif
 
     const SHADER_RESOURCE_VARIABLE_TYPE* AllowedVarTypes           = nullptr;
@@ -473,7 +473,7 @@ void ShaderResourceLayoutVk::Initialize(IRenderDevice*                    pRende
             {
                 auto& ImmutableSampler = ResLayout.GetImmutableSampler(CurrImmutableSamplerInd[ShaderInd]++);
                 VERIFY(!ImmutableSampler, "Immutable sampler has already been initialized!");
-                const auto& ImmutableSamplerDesc = ResourceLayoutDesc.StaticSamplers[SrcImmutableSamplerInd].Desc;
+                const auto& ImmutableSamplerDesc = ResourceLayoutDesc.ImmutableSamplers[SrcImmutableSamplerInd].Desc;
                 pRenderDevice->CreateSampler(ImmutableSamplerDesc, &ImmutableSampler);
                 vkImmutableSampler = ImmutableSampler.RawPtr<SamplerVkImpl>()->GetVkSampler();
             }