Renamed static sampler to immutable sampler (API240076)

5 files changed, 71 insertions, 67 deletions

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)