GraphicsEngineD3DBase: don't use auto where unnecessary

TheMostDiligent · TheMostDiligent · commit 200a58ddeadc · 2025-04-28T14:30:02.000-07:00
diff --git a/Graphics/GraphicsEngineD3DBase/src/D3DShaderResourceValidation.cpp b/Graphics/GraphicsEngineD3DBase/src/D3DShaderResourceValidation.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -70,7 +70,7 @@ void ValidateShaderResourceBindings(const char*                  PSOName,
                                     "' is not present in the resource bindings map.");
             }
 
-            const auto& Bindings = it->second;
+            const ResourceBinding::BindInfo& Bindings = it->second;
             if (Bindings.BindPoint != Attribs.BindPoint)
             {
                 LOG_ERROR_AND_THROW("Resource '", Attribs.Name, "' in shader '", Resources.GetShaderName(), "' of PSO '", PSOName,
diff --git a/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp b/Graphics/GraphicsEngineD3DBase/src/DXGITypeConversions.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -413,7 +413,7 @@ DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags)
 
     if (TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS)
     {
-        auto DXGIFormat = FmtToDXGIFmtMap[TexFormat];
+        DXGI_FORMAT DXGIFormat = FmtToDXGIFmtMap[TexFormat];
         VERIFY(TexFormat == TEX_FORMAT_UNKNOWN || TexFormat > TEX_FORMAT_BC7_UNORM_SRGB || DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format");
         if (BindFlags != 0)
             DXGIFormat = CorrectDXGIFormat(DXGIFormat, BindFlags);
@@ -433,7 +433,7 @@ class DXGIFmtToFmtMapInitializer
     {
         for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast<TEXTURE_FORMAT>(fmt + 1))
         {
-            auto DXGIFmt = TexFormatToDXGI_Format(fmt);
+            DXGI_FORMAT DXGIFmt = TexFormatToDXGI_Format(fmt);
             VERIFY_EXPR(DXGIFmt <= DXGI_FORMAT_B4G4R4A4_UNORM);
             DXGIFmtToFmtMap[DXGIFmt] = fmt;
         }
@@ -448,7 +448,7 @@ TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat)
 
     if (DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB)
     {
-        auto Format = DXGIFmtToFmtMap[DXGIFormat];
+        TEXTURE_FORMAT Format = DXGIFmtToFmtMap[DXGIFormat];
         VERIFY(DXGIFormat == DXGI_FORMAT_UNKNOWN || Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format");
         VERIFY_EXPR(DXGIFormat == TexFormatToDXGI_Format(Format));
         return Format;
diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -132,13 +132,13 @@ void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
     {
         constexpr Uint32 MaxOffset = std::numeric_limits<OffsetType>::max();
         VERIFY(CurrentOffset <= MaxOffset, "Current offset (", CurrentOffset, ") exceeds max allowed value (", MaxOffset, ")");
-        auto Offset = static_cast<OffsetType>(CurrentOffset);
+        OffsetType Offset = static_cast<OffsetType>(CurrentOffset);
         CurrentOffset += NumResources;
         return Offset;
     };
 
     // clang-format off
-    auto CBOffset        = AdvanceOffset(ResCounters.NumCBs);       (void)CBOffset; // To suppress warning
+    OffsetType CBOffset  = AdvanceOffset(ResCounters.NumCBs);       (void)CBOffset; // To suppress warning
     m_TexSRVOffset       = AdvanceOffset(ResCounters.NumTexSRVs);
     m_TexUAVOffset       = AdvanceOffset(ResCounters.NumTexUAVs);
     m_BufSRVOffset       = AdvanceOffset(ResCounters.NumBufSRVs);
@@ -147,8 +147,8 @@ void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
     m_AccelStructsOffset = AdvanceOffset(ResCounters.NumAccelStructs);
     m_TotalResources     = AdvanceOffset(0);
 
-    auto AlignedResourceNamesPoolSize = AlignUp(ResourceNamesPoolSize, sizeof(void*));
-    auto MemorySize = m_TotalResources * sizeof(D3DShaderResourceAttribs) + AlignedResourceNamesPoolSize * sizeof(char);
+    size_t AlignedResourceNamesPoolSize = AlignUp(ResourceNamesPoolSize, sizeof(void*));
+    size_t MemorySize = m_TotalResources * sizeof(D3DShaderResourceAttribs) + AlignedResourceNamesPoolSize * sizeof(char);
 
     VERIFY_EXPR(GetNumCBs()         == ResCounters.NumCBs);
     VERIFY_EXPR(GetNumTexSRV()      == ResCounters.NumTexSRVs);
@@ -161,7 +161,7 @@ void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator,
 
     if (MemorySize)
     {
-        auto* pRawMem   = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize);
+        void* pRawMem   = ALLOCATE_RAW(Allocator, "Allocator for shader resources", MemorySize);
         m_MemoryBuffer  = std::unique_ptr<void, STDDeleterRawMem<void>>(pRawMem, Allocator);
         char* NamesPool = reinterpret_cast<char*>(reinterpret_cast<D3DShaderResourceAttribs*>(pRawMem) + m_TotalResources);
         ResourceNamesPool.AssignMemory(NamesPool, ResourceNamesPoolSize);
@@ -180,11 +180,11 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
         std::string ShadersStr;
         while (ShaderStages != SHADER_TYPE_UNKNOWN)
         {
-            const auto ShaderType = ShaderStages & static_cast<SHADER_TYPE>(~(static_cast<Uint32>(ShaderStages) - 1));
-            String     ShaderName;
+            const SHADER_TYPE ShaderType = ShaderStages & static_cast<SHADER_TYPE>(~(static_cast<Uint32>(ShaderStages) - 1));
+            String            ShaderName;
             for (Uint32 s = 0; s < NumShaders; ++s)
             {
-                const auto& Resources = *pShaderResources[s];
+                const ShaderResources& Resources = *pShaderResources[s];
                 if ((ShaderStages & Resources.GetShaderType()) != 0)
                 {
                     if (ShaderName.size())
@@ -218,7 +218,7 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
     {
         for (Uint32 v = 0; v < ResourceLayout.NumVariables; ++v)
         {
-            const auto& VarDesc = ResourceLayout.Variables[v];
+            const ShaderResourceVariableDesc& VarDesc = ResourceLayout.Variables[v];
             if (VarDesc.ShaderStages == SHADER_TYPE_UNKNOWN)
             {
                 LOG_WARNING_MESSAGE("No allowed shader stages are specified for ", GetShaderVariableTypeLiteralName(VarDesc.Type), " variable '", VarDesc.Name, "'.");
@@ -228,14 +228,14 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
             bool VariableFound = false;
             for (Uint32 s = 0; s < NumShaders && !VariableFound; ++s)
             {
-                const auto& Resources = *pShaderResources[s];
+                const ShaderResources& Resources = *pShaderResources[s];
                 if ((VarDesc.ShaderStages & Resources.GetShaderType()) == 0)
                     continue;
 
-                const auto UseCombinedTextureSamplers = Resources.IsUsingCombinedTextureSamplers();
+                const bool UseCombinedTextureSamplers = Resources.IsUsingCombinedTextureSamplers();
                 for (Uint32 n = 0; n < Resources.m_TotalResources && !VariableFound; ++n)
                 {
-                    const auto& Res = Resources.GetResAttribs(n, Resources.m_TotalResources, 0);
+                    const D3DShaderResourceAttribs& Res = Resources.GetResAttribs(n, Resources.m_TotalResources, 0);
 
                     // Skip samplers if combined texture samplers are used as
                     // in this case they are not treated as independent variables
@@ -259,30 +259,30 @@ void ShaderResources::DvpVerifyResourceLayout(const PipelineResourceLayoutDesc&
     {
         for (Uint32 sam = 0; sam < ResourceLayout.NumImmutableSamplers; ++sam)
         {
-            const auto& StSamDesc = ResourceLayout.ImmutableSamplers[sam];
+            const ImmutableSamplerDesc& StSamDesc = ResourceLayout.ImmutableSamplers[sam];
             if (StSamDesc.ShaderStages == SHADER_TYPE_UNKNOWN)
             {
                 LOG_WARNING_MESSAGE("No allowed shader stages are specified for immutable sampler '", StSamDesc.SamplerOrTextureName, "'.");
                 continue;
             }
 
-            const auto* TexOrSamName = StSamDesc.SamplerOrTextureName;
+            const char* TexOrSamName = StSamDesc.SamplerOrTextureName;
 
             bool ImtblSamplerFound = false;
             for (Uint32 s = 0; s < NumShaders && !ImtblSamplerFound; ++s)
             {
-                const auto& Resources = *pShaderResources[s];
+                const ShaderResources& Resources = *pShaderResources[s];
                 if ((StSamDesc.ShaderStages & Resources.GetShaderType()) == 0)
                     continue;
 
                 // 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();
+                const char* CombinedSamplerSuffix = Resources.GetCombinedSamplerSuffix();
                 for (Uint32 n = 0; n < Resources.GetNumSamplers() && !ImtblSamplerFound; ++n)
                 {
-                    const auto& Sampler = Resources.GetSampler(n);
-                    ImtblSamplerFound   = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
+                    const D3DShaderResourceAttribs& Sampler = Resources.GetSampler(n);
+                    ImtblSamplerFound                       = StreqSuff(Sampler.Name, TexOrSamName, CombinedSamplerSuffix);
                 }
             }
 
@@ -301,10 +301,10 @@ Uint32 ShaderResources::FindAssignedSamplerId(const D3DShaderResourceAttribs& Te
 {
     VERIFY_EXPR(SamplerSuffix != nullptr && *SamplerSuffix != 0);
     VERIFY_EXPR(TexSRV.GetInputType() == D3D_SIT_TEXTURE && TexSRV.GetSRVDimension() != D3D_SRV_DIMENSION_BUFFER);
-    auto NumSamplers = GetNumSamplers();
+    Uint32 NumSamplers = GetNumSamplers();
     for (Uint32 s = 0; s < NumSamplers; ++s)
     {
-        const auto& Sampler = GetSampler(s);
+        const D3DShaderResourceAttribs& Sampler = GetSampler(s);
         if (StreqSuff(Sampler.Name, TexSRV.Name, SamplerSuffix))
         {
             DEV_CHECK_ERR(Sampler.BindCount == TexSRV.BindCount || Sampler.BindCount == 1, "Sampler '", Sampler.Name, "' assigned to texture '", TexSRV.Name, "' must be scalar or have the same array dimension (", TexSRV.BindCount, "). Actual sampler array dimension : ", Sampler.BindCount);
@@ -383,7 +383,7 @@ HLSLShaderResourceDesc ShaderResources::GetHLSLShaderResourceDesc(Uint32 Index)
     HLSLShaderResourceDesc HLSLResourceDesc = {};
     if (Index < m_TotalResources)
     {
-        const auto& Res = GetResAttribs(Index, m_TotalResources, 0);
+        const D3DShaderResourceAttribs& Res = GetResAttribs(Index, m_TotalResources, 0);
         return Res.GetHLSLResourceDesc();
     }
     return HLSLResourceDesc;
@@ -394,7 +394,7 @@ size_t ShaderResources::GetHash() const
     size_t hash = ComputeHash(GetNumCBs(), GetNumTexSRV(), GetNumTexUAV(), GetNumBufSRV(), GetNumBufUAV(), GetNumSamplers());
     for (Uint32 n = 0; n < m_TotalResources; ++n)
     {
-        const auto& Res = GetResAttribs(n, m_TotalResources, 0);
+        const D3DShaderResourceAttribs& Res = GetResAttribs(n, m_TotalResources, 0);
         HashCombine(hash, Res);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2022 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2025 Diligent Graphics LLC`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -70,7 +70,7 @@ void ValidateShaderResourceBindings(const char* PSOName,`
`70`	`70`	`"' is not present in the resource bindings map.");`
`71`	`71`	`}`
`72`	`72`
`73`		`- const auto& Bindings = it->second;`
	`73`	`+ const ResourceBinding::BindInfo& Bindings = it->second;`
`74`	`74`	`if (Bindings.BindPoint != Attribs.BindPoint)`
`75`	`75`	`{`
`76`	`76`	`LOG_ERROR_AND_THROW("Resource '", Attribs.Name, "' in shader '", Resources.GetShaderName(), "' of PSO '", PSOName,`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2024 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2025 Diligent Graphics LLC`
`3`	`3`	`* Copyright 2015-2019 Egor Yusov`
`4`	`4`	`*`
`5`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`@@ -413,7 +413,7 @@ DXGI_FORMAT TexFormatToDXGI_Format(TEXTURE_FORMAT TexFormat, Uint32 BindFlags)`
`413`	`413`
`414`	`414`	`if (TexFormat >= TEX_FORMAT_UNKNOWN && TexFormat < TEX_FORMAT_NUM_FORMATS)`
`415`	`415`	`{`
`416`		`- auto DXGIFormat = FmtToDXGIFmtMap[TexFormat];`
	`416`	`+ DXGI_FORMAT DXGIFormat = FmtToDXGIFmtMap[TexFormat];`
`417`	`417`	`VERIFY(TexFormat == TEX_FORMAT_UNKNOWN \|\| TexFormat > TEX_FORMAT_BC7_UNORM_SRGB \|\| DXGIFormat != DXGI_FORMAT_UNKNOWN, "Unsupported texture format");`
`418`	`418`	`if (BindFlags != 0)`
`419`	`419`	`DXGIFormat = CorrectDXGIFormat(DXGIFormat, BindFlags);`
`@@ -433,7 +433,7 @@ class DXGIFmtToFmtMapInitializer`
`433`	`433`	`{`
`434`	`434`	`for (TEXTURE_FORMAT fmt = TEX_FORMAT_UNKNOWN; fmt < TEX_FORMAT_NUM_FORMATS; fmt = static_cast<TEXTURE_FORMAT>(fmt + 1))`
`435`	`435`	`{`
`436`		`- auto DXGIFmt = TexFormatToDXGI_Format(fmt);`
	`436`	`+ DXGI_FORMAT DXGIFmt = TexFormatToDXGI_Format(fmt);`
`437`	`437`	`VERIFY_EXPR(DXGIFmt <= DXGI_FORMAT_B4G4R4A4_UNORM);`
`438`	`438`	`DXGIFmtToFmtMap[DXGIFmt] = fmt;`
`439`	`439`	`}`
`@@ -448,7 +448,7 @@ TEXTURE_FORMAT DXGI_FormatToTexFormat(DXGI_FORMAT DXGIFormat)`
`448`	`448`
`449`	`449`	`if (DXGIFormat >= DXGI_FORMAT_UNKNOWN && DXGIFormat <= DXGI_FORMAT_BC7_UNORM_SRGB)`
`450`	`450`	`{`
`451`		`- auto Format = DXGIFmtToFmtMap[DXGIFormat];`
	`451`	`+ TEXTURE_FORMAT Format = DXGIFmtToFmtMap[DXGIFormat];`
`452`	`452`	`VERIFY(DXGIFormat == DXGI_FORMAT_UNKNOWN \|\| Format != TEX_FORMAT_UNKNOWN, "Unsupported texture format");`
`453`	`453`	`VERIFY_EXPR(DXGIFormat == TexFormatToDXGI_Format(Format));`
`454`	`454`	`return Format;`