Shader D3D12/Vk/WebGPU: don't use auto where unnecessary

Author: TheMostDiligent

Graphics/GraphicsEngineD3D12/src/ShaderD3D12Impl.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");
@@ -45,15 +45,15 @@ static ShaderVersion GetD3D12ShaderModel(const ShaderCreateInfo& ShaderCI,
                                          IDXCompiler*            pDXCompiler,
                                          const ShaderVersion&    DeviceSM)
 {
-    auto HLSLVersion = ShaderCI.HLSLVersion;
+    ShaderVersion HLSLVersion = ShaderCI.HLSLVersion;
     if (HLSLVersion > DeviceSM)
     {
         LOG_WARNING_MESSAGE("Requested shader model ", Uint32{HLSLVersion.Major}, '_', Uint32{HLSLVersion.Minor},
                             " exceeds maximum version supported by device (",
                             Uint32{DeviceSM.Major}, '_', Uint32{DeviceSM.Minor}, ").");
     }
 
-    auto MaxSupportedSM = DeviceSM;
+    ShaderVersion MaxSupportedSM = DeviceSM;
     if (ShaderCI.Source != nullptr || ShaderCI.FilePath != nullptr)
     {
         ShaderVersion CompilerSM;
@@ -117,9 +117,9 @@ ShaderD3D12Impl::ShaderD3D12Impl(IReferenceCounters*     pRefCounters,
         GetD3D12ShaderModel(ShaderCI, D3D12ShaderCI.pDXCompiler, D3D12ShaderCI.MaxShaderVersion),
         [pDXCompiler      = D3D12ShaderCI.pDXCompiler,
          LoadCBReflection = ShaderCI.LoadConstantBufferReflection](const ShaderDesc& Desc, IDataBlob* pShaderByteCode) {
-            auto& Allocator  = GetRawAllocator();
-            auto* pRawMem    = ALLOCATE(Allocator, "Allocator for ShaderResources", ShaderResourcesD3D12, 1);
-            auto* pResources = new (pRawMem) ShaderResourcesD3D12 //
+            IMemoryAllocator&     Allocator  = GetRawAllocator();
+            ShaderResourcesD3D12* pRawMem    = ALLOCATE(Allocator, "Allocator for ShaderResources", ShaderResourcesD3D12, 1);
+            ShaderResourcesD3D12* pResources = new (pRawMem) ShaderResourcesD3D12 //
                 {
                     pShaderByteCode,
                     Desc,

Graphics/GraphicsEngineVulkan/src/ShaderVkImpl.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");
@@ -68,7 +68,7 @@ static constexpr char VulkanDefine[] =
 std::vector<uint32_t> CompileShaderDXC(const ShaderCreateInfo&         ShaderCI,
                                        const ShaderVkImpl::CreateInfo& VkShaderCI)
 {
-    auto* pDXCompiler = VkShaderCI.pDXCompiler;
+    IDXCompiler* pDXCompiler = VkShaderCI.pDXCompiler;
     VERIFY_EXPR(pDXCompiler != nullptr && pDXCompiler->IsLoaded());
     std::vector<uint32_t> SPIRV;
     pDXCompiler->Compile(ShaderCI, ShaderCI.HLSLVersion, VulkanDefine, nullptr, &SPIRV, VkShaderCI.ppCompilerOutput);
@@ -78,7 +78,7 @@ std::vector<uint32_t> CompileShaderDXC(const ShaderCreateInfo&         ShaderCI,
     {
         // SPIR-V bytecode generated from HLSL must be legalized to
         // turn it into a valid vulkan SPIR-V shader.
-        auto LegalizedSPIRV = OptimizeSPIRV(SPIRV, SPV_ENV_MAX, SPIRV_OPTIMIZATION_FLAG_LEGALIZATION);
+        std::vector<uint32_t> LegalizedSPIRV = OptimizeSPIRV(SPIRV, SPV_ENV_MAX, SPIRV_OPTIMIZATION_FLAG_LEGALIZATION);
         if (!LegalizedSPIRV.empty())
             SPIRV = std::move(LegalizedSPIRV);
         else
@@ -168,10 +168,10 @@ void ShaderVkImpl::Initialize(const ShaderCreateInfo& ShaderCI,
     {
         DEV_CHECK_ERR(ShaderCI.ByteCode == nullptr, "'ByteCode' must be null when shader is created from source code or a file");
 
-        auto ShaderCompiler = ShaderCI.ShaderCompiler;
+        SHADER_COMPILER ShaderCompiler = ShaderCI.ShaderCompiler;
         if (ShaderCompiler == SHADER_COMPILER_DXC)
         {
-            auto* pDXCompiler = VkShaderCI.pDXCompiler;
+            IDXCompiler* pDXCompiler = VkShaderCI.pDXCompiler;
             if (pDXCompiler == nullptr || !pDXCompiler->IsLoaded())
             {
                 LOG_WARNING_MESSAGE("DX Compiler is not loaded. Using default shader compiler");
@@ -219,13 +219,13 @@ void ShaderVkImpl::Initialize(const ShaderCreateInfo& ShaderCI,
     {
         if ((ShaderCI.CompileFlags & SHADER_COMPILE_FLAG_SKIP_REFLECTION) == 0)
         {
-            auto& Allocator = GetRawAllocator();
+            IMemoryAllocator& Allocator = GetRawAllocator();
 
             std::unique_ptr<void, STDDeleterRawMem<void>> pRawMem{
                 ALLOCATE(Allocator, "Memory for SPIRVShaderResources", SPIRVShaderResources, 1),
                 STDDeleterRawMem<void>(Allocator),
             };
-            auto LoadShaderInputs = m_Desc.ShaderType == SHADER_TYPE_VERTEX;
+            const bool LoadShaderInputs = m_Desc.ShaderType == SHADER_TYPE_VERTEX;
             new (pRawMem.get()) SPIRVShaderResources // May throw
                 {
                     Allocator,
@@ -322,20 +322,20 @@ void ShaderVkImpl::GetResourceDesc(Uint32 Index, ShaderResourceDesc& ResourceDes
 {
     DEV_CHECK_ERR(!IsCompiling(), "Shader resources are not available until the shader is compiled. Use GetStatus() to check the shader status.");
 
-    auto ResCount = GetResourceCount();
+    const Uint32 ResCount = GetResourceCount();
     DEV_CHECK_ERR(Index < ResCount, "Resource index (", Index, ") is out of range");
     if (Index < ResCount)
     {
-        const auto& SPIRVResource = m_pShaderResources->GetResource(Index);
-        ResourceDesc              = SPIRVResource.GetResourceDesc();
+        const SPIRVShaderResourceAttribs& SPIRVResource = m_pShaderResources->GetResource(Index);
+        ResourceDesc                                    = SPIRVResource.GetResourceDesc();
     }
 }
 
 const ShaderCodeBufferDesc* ShaderVkImpl::GetConstantBufferDesc(Uint32 Index) const
 {
     DEV_CHECK_ERR(!IsCompiling(), "Shader resources are not available until the shader is compiled. Use GetStatus() to check the shader status.");
 
-    auto ResCount = GetResourceCount();
+    const Uint32 ResCount = GetResourceCount();
     if (Index >= ResCount)
     {
         UNEXPECTED("Resource index (", Index, ") is out of range");

Graphics/GraphicsEngineWebGPU/src/ShaderWebGPUImpl.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2023-2024 Diligent Graphics LLC
+ *  Copyright 2023-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.
@@ -229,7 +229,7 @@ void ShaderWebGPUImpl::Initialize(const ShaderCreateInfo& ShaderCI,
     // Load shader resources
     if ((ShaderCI.CompileFlags & SHADER_COMPILE_FLAG_SKIP_REFLECTION) == 0)
     {
-        auto& Allocator = GetRawAllocator();
+        IMemoryAllocator& Allocator = GetRawAllocator();
 
         std::unique_ptr<void, STDDeleterRawMem<void>> pRawMem{
             ALLOCATE(Allocator, "Memory for WGSLShaderResources", WGSLShaderResources, 1),