Code refactoring: don't use auto where unnecessary

Author: TheMostDiligent

AssetLoader/src/DXSDKMeshLoader.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");
@@ -54,25 +54,25 @@ void DXSDKMesh::ComputeBoundingBoxes()
 {
     for (Uint32 i = 0; i < m_pMeshHeader->NumMeshes; i++)
     {
-        auto& Mesh = m_pMeshArray[i];
+        DXSDKMESH_MESH& Mesh = m_pMeshArray[i];
 
         float3 Min{+FLT_MAX, +FLT_MAX, +FLT_MAX};
         float3 Max{-FLT_MAX, -FLT_MAX, -FLT_MAX};
 
-        const auto& VertexData = m_pVertexBufferArray[Mesh.VertexBuffers[0]];
-        auto*       PosDecl    = VertexData.Decl;
+        const DXSDKMESH_VERTEX_BUFFER_HEADER& VertexData = m_pVertexBufferArray[Mesh.VertexBuffers[0]];
+        const DXSDKMESH_VERTEX_ELEMENT*       PosDecl    = VertexData.Decl;
         while (PosDecl->Stream != 0xFF && PosDecl->Usage != DXSDKMESH_VERTEX_SEMANTIC_POSITION)
             ++PosDecl;
         VERIFY(PosDecl->Stream != 0xFF, "Position semantic not found in this buffer");
         VERIFY(PosDecl->Type == DXSDKMESH_VERTEX_DATA_TYPE_FLOAT3, "Vertex is expected to be a 3-component float vector");
 
-        auto        IndexType = GetIndexType(i);
-        const auto* Vertices  = GetRawVerticesAt(Mesh.VertexBuffers[0]);
-        const auto* Indices   = GetRawIndicesAt(Mesh.IndexBuffer);
-        auto        Stride    = GetVertexStride(Mesh.VertexBuffers[0]);
+        DXSDKMESH_INDEX_TYPE IndexType = GetIndexType(i);
+        const Uint8*         Vertices  = GetRawVerticesAt(Mesh.VertexBuffers[0]);
+        const Uint8*         Indices   = GetRawIndicesAt(Mesh.IndexBuffer);
+        Uint32               Stride    = GetVertexStride(Mesh.VertexBuffers[0]);
         for (Uint32 subsetIdx = 0; subsetIdx < Mesh.NumSubsets; ++subsetIdx)
         {
-            auto& Subset = m_pSubsetArray[Mesh.pSubsets[subsetIdx]];
+            DXSDKMESH_SUBSET& Subset = m_pSubsetArray[Mesh.pSubsets[subsetIdx]];
 
             for (Uint32 v = 0; v < Subset.IndexCount; ++v)
             {
@@ -97,7 +97,7 @@ bool DXSDKMesh::CreateFromMemory(const Uint8* pData, Uint32 DataUint8s)
     memcpy(m_StaticMeshData.data(), pData, DataUint8s);
 
     // Pointer fixup
-    auto* pStaticMeshData = m_StaticMeshData.data();
+    Uint8* pStaticMeshData = m_StaticMeshData.data();
     // clang-format off
     m_pMeshHeader        = reinterpret_cast<DXSDKMESH_HEADER*>              (pStaticMeshData);
     m_pVertexBufferArray = reinterpret_cast<DXSDKMESH_VERTEX_BUFFER_HEADER*>(pStaticMeshData + m_pMeshHeader->VertexStreamHeadersOffset);
@@ -110,7 +110,7 @@ bool DXSDKMesh::CreateFromMemory(const Uint8* pData, Uint32 DataUint8s)
 
     for (Uint32 i = 0; i < m_pMeshHeader->NumMaterials; i++)
     {
-        auto& Mat            = m_pMaterialArray[i];
+        DXSDKMESH_MATERIAL& Mat{m_pMaterialArray[i]};
         Mat.pDiffuseTexture  = nullptr;
         Mat.pNormalTexture   = nullptr;
         Mat.pSpecularTexture = nullptr;
@@ -193,7 +193,7 @@ void DXSDKMesh::LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* p
     std::vector<StateTransitionDesc> Barriers;
     for (Uint32 i = 0; i < m_pMeshHeader->NumMaterials; i++)
     {
-        auto& Mat = m_pMaterialArray[i];
+        DXSDKMESH_MATERIAL& Mat = m_pMaterialArray[i];
         if (Mat.DiffuseTexture[0] != 0)
         {
             LoadTexture(pDevice, ResourceDirectory, Mat.DiffuseTexture, true, &Mat.pDiffuseTexture, &Mat.pDiffuseRV, Barriers);
@@ -213,7 +213,7 @@ void DXSDKMesh::LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* p
     m_VertexBuffers.resize(m_pMeshHeader->NumVertexBuffers);
     for (Uint32 i = 0; i < m_pMeshHeader->NumVertexBuffers; i++)
     {
-        const auto& VBArr = m_pVertexBufferArray[i];
+        const DXSDKMESH_VERTEX_BUFFER_HEADER& VBArr = m_pVertexBufferArray[i];
 
         std::stringstream ss;
         ss << "DXSDK Mesh vertex buffer #" << i;
@@ -234,7 +234,7 @@ void DXSDKMesh::LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* p
     m_IndexBuffers.resize(m_pMeshHeader->NumIndexBuffers);
     for (Uint32 i = 0; i < m_pMeshHeader->NumIndexBuffers; i++)
     {
-        const auto& IBArr = m_pIndexBufferArray[i];
+        const DXSDKMESH_INDEX_BUFFER_HEADER& IBArr = m_pIndexBufferArray[i];
 
         std::stringstream ss;
         ss << "DXSDK Mesh index buffer #" << i;
@@ -278,7 +278,7 @@ void DXSDKMesh::Destroy()
 {
     for (Uint32 i = 0; i < m_pMeshHeader->NumMaterials; i++)
     {
-        auto& Mat = m_pMaterialArray[i];
+        DXSDKMESH_MATERIAL& Mat = m_pMaterialArray[i];
         if (Mat.pDiffuseTexture)
             Mat.pDiffuseTexture->Release();
 

AssetLoader/src/GLTFBuilder.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 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.
@@ -51,7 +51,7 @@ size_t ModelBuilder::PrimitiveKey::Hasher::operator()(const PrimitiveKey& Key) c
     if (Key.Hash == 0)
     {
         Key.Hash = ComputeHash(Key.AccessorIds.size());
-        for (auto Id : Key.AccessorIds)
+        for (int Id : Key.AccessorIds)
             HashCombine(Key.Hash, Id);
     }
     return Key.Hash;
@@ -79,7 +79,7 @@ inline Uint8 ConvertElement<Uint8, false, float>(float Src)
 template <>
 inline Int8 ConvertElement<Int8, true, float>(float Src)
 {
-    auto r = Src > 0.f ? +0.5f : -0.5f;
+    float r = Src > 0.f ? +0.5f : -0.5f;
     return static_cast<Int8>(clamp(Src * 127.f + r, -127.f, 127.f));
 }
 
@@ -128,7 +128,7 @@ inline void WriteGltfData(const void*                  pSrc,
 {
     for (size_t elem = 0; elem < NumElements; ++elem)
     {
-        const auto* pSrcCmp = reinterpret_cast<const SrcType*>(static_cast<const Uint8*>(pSrc) + SrcElemStride * elem);
+        const SrcType* pSrcCmp = reinterpret_cast<const SrcType*>(static_cast<const Uint8*>(pSrc) + SrcElemStride * elem);
 
         auto comp_it = dst_it + DstElementStride * elem;
         for (Uint32 cmp = 0; cmp < NumComponents; ++cmp, comp_it += sizeof(DstType))
@@ -140,7 +140,7 @@ inline void WriteGltfData(const void*                  pSrc,
 
 void ModelBuilder::WriteGltfData(const WriteGltfDataAttribs& Attribs)
 {
-    const auto NumComponentsToCopy = std::min(Attribs.NumSrcComponents, Attribs.NumDstComponents);
+    const Uint32 NumComponentsToCopy = std::min(Attribs.NumSrcComponents, Attribs.NumDstComponents);
 
 #define INNER_CASE(SrcType, DstType)                                            \
     case DstType:                                                               \
@@ -205,7 +205,7 @@ void ModelBuilder::WriteDefaultAttibuteValue(const void*                  pDefau
                                              Uint32                       DstElementStride,
                                              Uint32                       NumElements)
 {
-    auto ElementSize = GetValueSize(DstType) * NumDstComponents;
+    Uint32 ElementSize = GetValueSize(DstType) * NumDstComponents;
     VERIFY(DstElementStride >= ElementSize, "Destination element stride is too small");
     for (size_t elem = 0; elem < NumElements; ++elem)
     {
@@ -216,13 +216,13 @@ void ModelBuilder::WriteDefaultAttibuteValue(const void*                  pDefau
 
 void ModelBuilder::WriteDefaultAttibutes(Uint32 BufferId, size_t StartOffset, size_t EndOffset)
 {
-    const auto VertexStride = m_Model.VertexData.Strides[BufferId];
+    const Uint32 VertexStride = m_Model.VertexData.Strides[BufferId];
     VERIFY(StartOffset % VertexStride == 0, "Start offset is not aligned to vertex stride");
     VERIFY(EndOffset % VertexStride == 0, "End offset is not aligned to vertex stride");
-    const auto NumVertices = static_cast<Uint32>((EndOffset - StartOffset) / VertexStride);
+    const Uint32 NumVertices = static_cast<Uint32>((EndOffset - StartOffset) / VertexStride);
     for (Uint32 i = 0; i < m_Model.GetNumVertexAttributes(); ++i)
     {
-        const auto& Attrib = m_Model.VertexAttributes[i];
+        const VertexAttributeDesc& Attrib = m_Model.VertexAttributes[i];
         if (BufferId != Attrib.BufferId || Attrib.pDefaultValue == nullptr)
             continue;
 
@@ -244,14 +244,14 @@ void ModelBuilder::InitIndexBuffer(IRenderDevice* pDevice)
     VERIFY_EXPR((m_IndexData.size() % m_Model.IndexData.IndexSize) == 0);
     VERIFY(!m_Model.IndexData.pBuffer && !m_Model.IndexData.pAllocation, "Index buffer has already been initialized");
 
-    const auto DataSize = static_cast<Uint32>(m_IndexData.size());
+    const Uint32 DataSize = static_cast<Uint32>(m_IndexData.size());
     if (m_CI.pResourceManager != nullptr)
     {
         m_Model.IndexData.pAllocation = m_CI.pResourceManager->AllocateIndices(DataSize, 4);
 
         if (m_Model.IndexData.pAllocation)
         {
-            auto pBuffInitData = BufferInitData::Create();
+            RefCntAutoPtr<BufferInitData> pBuffInitData = BufferInitData::Create();
             pBuffInitData->Data.emplace_back(std::move(m_IndexData));
             m_Model.IndexData.pAllocation->SetUserData(pBuffInitData);
 
@@ -265,8 +265,8 @@ void ModelBuilder::InitIndexBuffer(IRenderDevice* pDevice)
     }
     else
     {
-        const auto BindFlags = m_CI.IndBufferBindFlags != BIND_NONE ? m_CI.IndBufferBindFlags : BIND_INDEX_BUFFER;
-        BufferDesc BuffDesc{"GLTF index buffer", DataSize, BindFlags, USAGE_IMMUTABLE};
+        const BIND_FLAGS BindFlags = m_CI.IndBufferBindFlags != BIND_NONE ? m_CI.IndBufferBindFlags : BIND_INDEX_BUFFER;
+        BufferDesc       BuffDesc{"GLTF index buffer", DataSize, BindFlags, USAGE_IMMUTABLE};
         if (BuffDesc.BindFlags & (BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS))
         {
             BuffDesc.Mode              = BUFFER_MODE_FORMATTED;
@@ -286,7 +286,7 @@ void ModelBuilder::InitVertexBuffers(IRenderDevice* pDevice)
         return;
     }
 
-    const auto VBCount = m_Model.GetVertexBufferCount();
+    const size_t VBCount = m_Model.GetVertexBufferCount();
     VERIFY_EXPR(m_VertexData.size() == VBCount);
 
     size_t NumVertices = 0;
@@ -317,16 +317,16 @@ void ModelBuilder::InitVertexBuffers(IRenderDevice* pDevice)
         LayoutKey.Elements.reserve(VBCount);
         for (Uint32 i = 0; i < VBCount; ++i)
         {
-            const auto BindFlags = m_CI.VertBufferBindFlags[i] != BIND_NONE ? m_CI.VertBufferBindFlags[i] : BIND_VERTEX_BUFFER;
+            const BIND_FLAGS BindFlags = m_CI.VertBufferBindFlags[i] != BIND_NONE ? m_CI.VertBufferBindFlags[i] : BIND_VERTEX_BUFFER;
             LayoutKey.Elements.emplace_back(m_Model.VertexData.Strides[i], BindFlags);
         }
 
         VERIFY(!m_Model.VertexData.pAllocation, "This vertex buffer has already been initialized");
         m_Model.VertexData.pAllocation = m_CI.pResourceManager->AllocateVertices(LayoutKey, static_cast<Uint32>(NumVertices));
         if (m_Model.VertexData.pAllocation)
         {
-            auto pBuffInitData  = BufferInitData::Create();
-            pBuffInitData->Data = std::move(m_VertexData);
+            RefCntAutoPtr<BufferInitData> pBuffInitData = BufferInitData::Create();
+            pBuffInitData->Data                         = std::move(m_VertexData);
             m_Model.VertexData.pAllocation->SetUserData(pBuffInitData);
             m_Model.VertexData.PoolId = m_CI.pResourceManager->GetVertexPoolIndex(LayoutKey, m_Model.VertexData.pAllocation->GetPool());
             VERIFY_EXPR(m_Model.VertexData.PoolId != ~0u);
@@ -342,16 +342,16 @@ void ModelBuilder::InitVertexBuffers(IRenderDevice* pDevice)
         m_Model.VertexData.Buffers.resize(VBCount);
         for (Uint32 i = 0; i < VBCount; ++i)
         {
-            const auto& Data = m_VertexData[i];
+            const std::vector<Uint8>& Data = m_VertexData[i];
             if (Data.empty())
                 continue;
 
-            const auto DataSize  = static_cast<Uint32>(Data.size());
-            const auto Name      = std::string{"GLTF vertex buffer "} + std::to_string(i);
-            const auto BindFlags = m_CI.VertBufferBindFlags[i] != BIND_NONE ? m_CI.VertBufferBindFlags[i] : BIND_VERTEX_BUFFER;
-            BufferDesc BuffDesc{Name.c_str(), DataSize, BindFlags, USAGE_IMMUTABLE};
+            const Uint32      DataSize  = static_cast<Uint32>(Data.size());
+            const std::string Name      = std::string{"GLTF vertex buffer "} + std::to_string(i);
+            const BIND_FLAGS  BindFlags = m_CI.VertBufferBindFlags[i] != BIND_NONE ? m_CI.VertBufferBindFlags[i] : BIND_VERTEX_BUFFER;
+            BufferDesc        BuffDesc{Name.c_str(), DataSize, BindFlags, USAGE_IMMUTABLE};
 
-            const auto ElementStride = m_Model.VertexData.Strides[i];
+            const Uint32 ElementStride = m_Model.VertexData.Strides[i];
             VERIFY_EXPR(ElementStride > 0);
             VERIFY_EXPR(Data.size() % ElementStride == 0);
 

AssetLoader/src/GLTFResourceManager.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");
@@ -41,8 +41,8 @@ namespace GLTF
 
 size_t ResourceManager::VertexLayoutKey::Hasher::operator()(const VertexLayoutKey& Key) const
 {
-    auto Hash = ComputeHash(Key.Elements.size());
-    for (const auto& Elem : Key.Elements)
+    size_t Hash = ComputeHash(Key.Elements.size());
+    for (const ElementDesc& Elem : Key.Elements)
         HashCombine(Hash, Elem.Size, Elem.BindFlags);
     return Hash;
 }
@@ -88,13 +88,13 @@ ResourceManager::ResourceManager(IReferenceCounters* pRefCounters,
     m_VertexPoolCIs.reserve(CI.NumVertexPools);
     for (Uint32 pool = 0; pool < CI.NumVertexPools; ++pool)
     {
-        const auto& PoolCI = CI.pVertexPoolCIs[pool];
+        const VertexPoolCreateInfo& PoolCI = CI.pVertexPoolCIs[pool];
 
         VertexLayoutKey Key;
         Key.Elements.reserve(PoolCI.Desc.NumElements);
         for (size_t i = 0; i < PoolCI.Desc.NumElements; ++i)
         {
-            const auto& PoolElem = PoolCI.Desc.pElements[i];
+            const VertexPoolElementDesc& PoolElem = PoolCI.Desc.pElements[i];
             Key.Elements.emplace_back(PoolElem.Size, PoolElem.BindFlags);
         }
 
@@ -112,7 +112,7 @@ ResourceManager::ResourceManager(IReferenceCounters* pRefCounters,
     m_Atlases.reserve(CI.NumTexAtlases);
     for (Uint32 i = 0; i < CI.NumTexAtlases; ++i)
     {
-        const auto& AtlasCI = CI.pTexAtlasCIs[i];
+        const DynamicTextureAtlasCreateInfo& AtlasCI = CI.pTexAtlasCIs[i];
 
         RefCntAutoPtr<IDynamicTextureAtlas> pAtlas;
         CreateDynamicTextureAtlas(pDevice, AtlasCI, &pAtlas);
@@ -171,8 +171,8 @@ RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::AllocateTextureSpace(
                     return {};
                 }
 
-                auto AtalsCreateInfo        = m_DefaultAtlasDesc;
-                AtalsCreateInfo.Desc.Format = Fmt;
+                DynamicTextureAtlasCreateInfo AtalsCreateInfo = m_DefaultAtlasDesc;
+                AtalsCreateInfo.Desc.Format                   = Fmt;
 
                 RefCntAutoPtr<IDynamicTextureAtlas> pAtlas;
                 CreateDynamicTextureAtlas(nullptr, AtalsCreateInfo, &pAtlas);
@@ -257,7 +257,7 @@ RefCntAutoPtr<IVertexPool> ResourceManager::CreateVertexPoolForLayout(const Vert
         std::vector<VertexPoolElementDesc> PoolElems(Key.Elements.size());
         for (size_t i = 0; i < PoolElems.size(); ++i)
         {
-            auto& ElemDesc = PoolElems[i];
+            VertexPoolElementDesc& ElemDesc = PoolElems[i];
 
             ElemDesc.Size           = Key.Elements[i].Size;
             ElemDesc.BindFlags      = Key.Elements[i].BindFlags;
@@ -284,7 +284,7 @@ RefCntAutoPtr<IVertexPoolAllocation> ResourceManager::AllocateVertices(const Ver
 {
 #ifdef DILIGENT_DEVELOPMENT
     DEV_CHECK_ERR(!LayoutKey.Elements.empty(), "The key must not be empty.");
-    for (const auto& Elem : LayoutKey.Elements)
+    for (const VertexLayoutKey::ElementDesc& Elem : LayoutKey.Elements)
     {
         DEV_CHECK_ERR(Elem.Size != 0, "Element size must not be zero.");
         DEV_CHECK_ERR(Elem.BindFlags != BIND_NONE, "Bind flags must not be NONE.");

HLSL2GLSLConverter/src/HLSL2GLSLConverterApp.cpp

@@ -119,7 +119,7 @@ int HLSL2GLSLConverterApp::ParseCmdLine(int argc, char** argv)
 
     m_InputPath  = InputArg.Get();
     m_OutputPath = OutputArg.Get();
-    for (const auto& Dir : SearDirsArg.Get())
+    for (const std::string& Dir : SearDirsArg.Get())
     {
         if (!m_SearchDirectories.empty())
             m_SearchDirectories.push_back(';');
@@ -162,10 +162,10 @@ int HLSL2GLSLConverterApp::Convert(IRenderDevice* pDevice)
     {
         return -1;
     }
-    auto pHLSLSourceBlob = DataBlobImpl::Create();
+    RefCntAutoPtr<DataBlobImpl> pHLSLSourceBlob = DataBlobImpl::Create();
     pInputFileStream->ReadBlob(pHLSLSourceBlob);
     char* HLSLSource = pHLSLSourceBlob->GetDataPtr<char>();
-    auto  SourceLen  = static_cast<Int32>(pHLSLSourceBlob->GetSize());
+    Int32 SourceLen  = static_cast<Int32>(pHLSLSourceBlob->GetSize());
 
     RefCntAutoPtr<IHLSL2GLSLConverter> pConverter;
     CreateHLSL2GLSLConverter(&pConverter);

HLSL2GLSLConverter/src/HLSL2GLSLConverterAppWin32.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");
@@ -76,7 +76,7 @@ int main(int argc, char** argv)
     HLSL2GLSLConverterApp Converter;
 
     {
-        auto ret = Converter.ParseCmdLine(argc, argv);
+        int ret = Converter.ParseCmdLine(argc, argv);
         if (ret != 0)
             return ret;
     }
@@ -108,7 +108,7 @@ int main(int argc, char** argv)
         SwapChainDesc      SCDesc;
         EngineCI.Window.hWnd = wnd;
 
-        auto* pFactory = Converter.GetFactoryGL();
+        IEngineFactoryOpenGL* pFactory = Converter.GetFactoryGL();
         pFactory->CreateDeviceAndSwapChainGL(
             EngineCI, &pDevice, &pContext, SCDesc, &pSwapChain);
         if (!pDevice)