refactor: fix x64 compilation for ObjLoading

src/Common/Game/IW3/IW3_Assets.h

@@ -1314,9 +1314,9 @@ namespace IW3
     {
         char levelCount;
         char flags;
-        int16_t dimensions[3];
+        uint16_t dimensions[3];
         int format;
-        int resourceSize;
+        unsigned int resourceSize;
         char data[1];
     };
 

src/Common/Game/T6/T6_Assets.h

@@ -1478,8 +1478,8 @@ namespace T6
     struct FontIcon
     {
         const char* name;
-        int numEntries;
+        unsigned int numEntries;
-        int numAliasEntries;
+        unsigned int numAliasEntries;
         FontIconEntry* fontIconEntry;
         FontIconAlias* fontIconAlias;
     };

src/ObjCommon/StructuredDataDef/CommonStructuredDataStruct.h

@@ -1,6 +1,6 @@
 #pragma once
+
 #include "CommonStructuredDataTypes.h"
-#include "Utils/ClassUtils.h"
 
 #include <cstdint>
 #include <string>
@@ -8,29 +8,29 @@
 
 struct CommonStructuredDataStructProperty
 {
-    std::string m_name;
-    CommonStructuredDataType m_type;
-    size_t m_offset_in_bits;
-
     CommonStructuredDataStructProperty();
     explicit CommonStructuredDataStructProperty(std::string name);
     CommonStructuredDataStructProperty(std::string name, CommonStructuredDataType type, size_t offsetInBits);
+
+    std::string m_name;
+    CommonStructuredDataType m_type;
+    size_t m_offset_in_bits;
 };
 
 class CommonStructuredDataDef;
 
 struct CommonStructuredDataStruct
 {
+    CommonStructuredDataStruct();
+    explicit CommonStructuredDataStruct(std::string name);
+
+    [[nodiscard]] uint32_t CalculateChecksum(const CommonStructuredDataDef& def, uint32_t initialValue) const;
+
+    void SortPropertiesByOffset();
+    void SortPropertiesByName();
+
     std::string m_name;
     std::vector<CommonStructuredDataStructProperty> m_properties;
     size_t m_bit_offset;
     size_t m_size_in_byte;
-
-    CommonStructuredDataStruct();
-    explicit CommonStructuredDataStruct(std::string name);
-
-    _NODISCARD uint32_t CalculateChecksum(const CommonStructuredDataDef& def, uint32_t initialValue) const;
-
-    void SortPropertiesByOffset();
-    void SortPropertiesByName();
 };

src/ObjLoading/Game/IW3/Image/AssetLoaderImageIW3.cpp

@@ -81,7 +81,7 @@ namespace
             const auto mipCount = texture->HasMipMaps() ? texture->GetMipMapCount() : 1;
             const auto faceCount = texture->GetFaceCount();
 
-            size_t dataSize = 0;
+            auto dataSize = 0uz;
             for (auto mipLevel = 0; mipLevel < mipCount; mipLevel++)
                 dataSize += texture->GetSizeOfMipLevel(mipLevel) * faceCount;
 
@@ -99,7 +99,7 @@ namespace
             loadDef->dimensions[1] = image->height;
             loadDef->dimensions[2] = image->depth;
             loadDef->format = static_cast<int>(texture->GetFormat()->GetD3DFormat());
-            loadDef->resourceSize = dataSize;
+            loadDef->resourceSize = static_cast<unsigned>(dataSize);
 
             char* currentDataBuffer = loadDef->data;
             for (auto mipLevel = 0; mipLevel < mipCount; mipLevel++)

src/ObjLoading/Game/IW4/Menu/LoaderMenuListIW4.cpp

@@ -83,7 +83,7 @@ namespace
                                    menu::MenuAssetZoneState& zoneState,
                                    MenuConversionZoneState& conversionState,
                                    std::vector<menuDef_t*>& menus,
-                                   AssetRegistration<AssetMenuList>& registration)
+                                   AssetRegistration<AssetMenuList>& registration) const
         {
             const auto alreadyLoadedMenuFile = conversionState.m_menus_by_filename.find(menuFilePath);
             if (alreadyLoadedMenuFile != conversionState.m_menus_by_filename.end())
@@ -125,12 +125,12 @@ namespace
                                   menu::MenuAssetZoneState& zoneState,
                                   MenuConversionZoneState& conversionState,
                                   std::vector<menuDef_t*>& menus,
-                                  AssetRegistration<AssetMenuList>& registration)
+                                  AssetRegistration<AssetMenuList>& registration) const
         {
             const auto menuCount = parsingResult.m_menus.size();
             const auto functionCount = parsingResult.m_functions.size();
             const auto menuLoadCount = parsingResult.m_menus_to_load.size();
-            auto totalItemCount = 0u;
+            auto totalItemCount = 0uz;
             for (const auto& menu : parsingResult.m_menus)
                 totalItemCount += menu->m_items.size();
 
@@ -182,7 +182,7 @@ namespace
             return true;
         }
 
-        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus)
+        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus) const
         {
             menuList.menuCount = static_cast<int>(menus.size());
 
@@ -196,7 +196,8 @@ namespace
                 menuList.menus = nullptr;
         }
 
-        std::unique_ptr<menu::ParsingResult> ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState)
+        std::unique_ptr<menu::ParsingResult>
+            ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState) const
         {
             menu::MenuFileReader reader(stream, menuFileName, menu::FeatureLevel::IW4, m_search_path);
 

src/ObjLoading/Game/IW4/RawFile/LoaderRawFileIW4.cpp

@@ -43,7 +43,7 @@ namespace
             zs.zfree = Z_NULL;
             zs.opaque = Z_NULL;
             zs.avail_in = static_cast<uInt>(file.m_length);
-            zs.avail_out = compressionBufferSize;
+            zs.avail_out = static_cast<unsigned>(compressionBufferSize);
             zs.next_in = reinterpret_cast<const Bytef*>(uncompressedBuffer.get());
             zs.next_out = reinterpret_cast<Bytef*>(compressedBuffer);
 

src/ObjLoading/Game/IW4/StructuredDataDef/LoaderStructuredDataDefIW4.cpp

@@ -38,38 +38,38 @@ namespace
         }
 
     private:
-        StructuredDataType ConvertType(CommonStructuredDataType inputType)
+        static StructuredDataType ConvertType(const CommonStructuredDataType inputType)
         {
             switch (inputType.m_category)
             {
             case CommonStructuredDataTypeCategory::INT:
-                return {DATA_INT, {0}};
+                return {.type = DATA_INT, .u = {}};
             case CommonStructuredDataTypeCategory::BYTE:
-                return {DATA_BYTE, {0}};
+                return {.type = DATA_BYTE, .u = {}};
             case CommonStructuredDataTypeCategory::BOOL:
-                return {DATA_BOOL, {0}};
+                return {.type = DATA_BOOL, .u = {}};
             case CommonStructuredDataTypeCategory::FLOAT:
-                return {DATA_FLOAT, {0}};
+                return {.type = DATA_FLOAT, .u = {}};
             case CommonStructuredDataTypeCategory::SHORT:
-                return {DATA_SHORT, {0}};
+                return {.type = DATA_SHORT, .u = {}};
             case CommonStructuredDataTypeCategory::STRING:
-                return {DATA_STRING, {static_cast<unsigned>(inputType.m_info.string_length)}};
+                return {.type = DATA_STRING, .u = {static_cast<unsigned>(inputType.m_info.string_length)}};
             case CommonStructuredDataTypeCategory::ENUM:
-                return {DATA_ENUM, {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {.type = DATA_ENUM, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::STRUCT:
-                return {DATA_STRUCT, {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {.type = DATA_STRUCT, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::INDEXED_ARRAY:
-                return {DATA_INDEXED_ARRAY, {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {.type = DATA_INDEXED_ARRAY, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::ENUM_ARRAY:
-                return {DATA_ENUM_ARRAY, {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {.type = DATA_ENUM_ARRAY, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::UNKNOWN:
             default:
                 assert(false);
-                return {DATA_INT, {0}};
+                return {.type = DATA_INT, .u = {0}};
             }
         }
 
-        void ConvertEnum(CommonStructuredDataEnum& inputEnum, StructuredDataEnum& outputEnum)
+        void ConvertEnum(CommonStructuredDataEnum& inputEnum, StructuredDataEnum& outputEnum) const
         {
             outputEnum.entryCount = static_cast<int>(inputEnum.m_entries.size());
             if (inputEnum.m_reserved_entry_count <= 0)
@@ -94,10 +94,10 @@ namespace
                 outputEnum.entries = nullptr;
         }
 
-        void ConvertStruct(CommonStructuredDataStruct& inputStruct, StructuredDataStruct& outputStruct)
+        void ConvertStruct(CommonStructuredDataStruct& inputStruct, StructuredDataStruct& outputStruct) const
         {
             outputStruct.size = static_cast<int>(inputStruct.m_size_in_byte);
-            outputStruct.bitOffset = inputStruct.m_bit_offset;
+            outputStruct.bitOffset = static_cast<unsigned>(inputStruct.m_bit_offset);
 
             outputStruct.propertyCount = static_cast<int>(inputStruct.m_properties.size());
             inputStruct.SortPropertiesByName();
@@ -115,34 +115,34 @@ namespace
                     if (outputProperty.type.type != DATA_BOOL)
                     {
                         assert(inputProperty.m_offset_in_bits % 8 == 0);
-                        outputProperty.offset = inputProperty.m_offset_in_bits / 8;
+                        outputProperty.offset = static_cast<unsigned>(inputProperty.m_offset_in_bits / 8uz);
                     }
                     else
-                        outputProperty.offset = inputProperty.m_offset_in_bits;
+                        outputProperty.offset = static_cast<unsigned>(inputProperty.m_offset_in_bits);
                 }
             }
             else
                 outputStruct.properties = nullptr;
         }
 
-        void ConvertIndexedArray(const CommonStructuredDataIndexedArray& inputIndexedArray, StructuredDataIndexedArray& outputIndexedArray)
+        static void ConvertIndexedArray(const CommonStructuredDataIndexedArray& inputIndexedArray, StructuredDataIndexedArray& outputIndexedArray)
         {
             outputIndexedArray.arraySize = static_cast<int>(inputIndexedArray.m_element_count);
             outputIndexedArray.elementType = ConvertType(inputIndexedArray.m_array_type);
-            outputIndexedArray.elementSize = utils::Align(inputIndexedArray.m_element_size_in_bits, 8uz) / 8uz;
+            outputIndexedArray.elementSize = static_cast<unsigned>(utils::Align(inputIndexedArray.m_element_size_in_bits, 8uz) / 8uz);
         }
 
         void ConvertEnumedArray(const CommonStructuredDataEnumedArray& inputEnumedArray, StructuredDataEnumedArray& outputEnumedArray)
         {
             outputEnumedArray.enumIndex = static_cast<int>(inputEnumedArray.m_enum_index);
             outputEnumedArray.elementType = ConvertType(inputEnumedArray.m_array_type);
-            outputEnumedArray.elementSize = utils::Align(inputEnumedArray.m_element_size_in_bits, 8uz) / 8uz;
+            outputEnumedArray.elementSize = static_cast<unsigned>(utils::Align(inputEnumedArray.m_element_size_in_bits, 8uz) / 8uz);
         }
 
         void ConvertDef(const CommonStructuredDataDef& inputDef, StructuredDataDef& outputDef)
         {
             outputDef.version = inputDef.m_version;
-            outputDef.formatChecksum = inputDef.m_checksum;
+            outputDef.formatChecksum = static_cast<unsigned>(inputDef.m_checksum);
 
             outputDef.enumCount = static_cast<int>(inputDef.m_enums.size());
             if (!inputDef.m_enums.empty())
@@ -185,7 +185,7 @@ namespace
                 outputDef.enumedArrays = nullptr;
 
             outputDef.rootType = ConvertType(inputDef.m_root_type);
-            outputDef.size = inputDef.m_size_in_byte;
+            outputDef.size = static_cast<unsigned>(inputDef.m_size_in_byte);
         }
 
         StructuredDataDefSet* ConvertSet(const std::string& assetName, const std::vector<std::unique_ptr<CommonStructuredDataDef>>& commonDefs)
@@ -193,7 +193,7 @@ namespace
             auto* set = m_memory.Alloc<StructuredDataDefSet>();
             set->name = m_memory.Dup(assetName.c_str());
 
-            set->defCount = commonDefs.size();
+            set->defCount = static_cast<unsigned>(commonDefs.size());
             set->defs = m_memory.Alloc<StructuredDataDef>(commonDefs.size());
 
             for (auto defIndex = 0u; defIndex < commonDefs.size(); defIndex++)

src/ObjLoading/Game/IW4/Techset/LoaderTechsetIW4.cpp

@@ -31,14 +31,14 @@ namespace
     class LoadedTechnique
     {
     public:
-        MaterialTechnique* m_technique;
-        std::vector<XAssetInfoGeneric*> m_dependencies;
-
         LoadedTechnique(MaterialTechnique* technique, std::vector<XAssetInfoGeneric*> dependencies)
             : m_technique(technique),
               m_dependencies(std::move(dependencies))
         {
         }
+
+        MaterialTechnique* m_technique;
+        std::vector<XAssetInfoGeneric*> m_dependencies;
     };
 
     class TechniqueZoneLoadingState final : public IZoneAssetCreationState
@@ -46,8 +46,7 @@ namespace
     public:
         typedef const float (*literal_t)[4];
 
-    public:
+        [[nodiscard]] const LoadedTechnique* FindLoadedTechnique(const std::string& techniqueName) const
-        _NODISCARD const LoadedTechnique* FindLoadedTechnique(const std::string& techniqueName) const
         {
             const auto loadedTechnique = m_loaded_techniques.find(techniqueName);
             if (loadedTechnique != m_loaded_techniques.end())
@@ -86,8 +85,6 @@ namespace
 
     class ShaderInfoFromFileSystemCacheState final : public IZoneAssetCreationState
     {
-        std::unordered_map<std::string, std::unique_ptr<d3d9::ShaderInfo>> m_cached_shader_info;
-
     public:
         [[nodiscard]] const d3d9::ShaderInfo* LoadShaderInfoFromDisk(ISearchPath& searchPath, const std::string& fileName)
         {
@@ -108,9 +105,9 @@ namespace
             }
 
             const auto shaderData = std::make_unique<char[]>(shaderSize);
-            file.m_stream->read(shaderData.get(), shaderSize);
+            file.m_stream->read(shaderData.get(), static_cast<std::streamsize>(shaderSize));
 
-            auto shaderInfo = d3d9::ShaderAnalyser::GetShaderInfo(reinterpret_cast<const uint32_t*>(shaderData.get()), shaderSize);
+            auto shaderInfo = d3d9::ShaderAnalyser::GetShaderInfo(shaderData.get(), shaderSize);
             if (!shaderInfo)
                 return nullptr;
 
@@ -118,6 +115,9 @@ namespace
             m_cached_shader_info.emplace(std::make_pair(fileName, std::move(shaderInfo)));
             return result;
         }
+
+    private:
+        std::unordered_map<std::string, std::unique_ptr<d3d9::ShaderInfo>> m_cached_shader_info;
     };
 
     class TechniqueCreator final : public techset::ITechniqueDefinitionAcceptor
@@ -126,10 +126,13 @@ namespace
         class PassShaderArgument
         {
         public:
-            MaterialShaderArgument m_arg;
+            explicit PassShaderArgument(const MaterialShaderArgument arg)
-            MaterialUpdateFrequency m_update_frequency;
+                : m_arg(arg),
+                  m_update_frequency(GetUpdateFrequencyForArg(arg))
+            {
+            }
 
-            static MaterialUpdateFrequency GetUpdateFrequencyForArg(MaterialShaderArgument arg)
+            static MaterialUpdateFrequency GetUpdateFrequencyForArg(const MaterialShaderArgument arg)
             {
                 switch (arg.type)
                 {
@@ -160,15 +163,22 @@ namespace
                 }
             }
 
-            explicit PassShaderArgument(const MaterialShaderArgument arg)
+            MaterialShaderArgument m_arg;
-                : m_arg(arg),
+            MaterialUpdateFrequency m_update_frequency;
-                  m_update_frequency(GetUpdateFrequencyForArg(arg))
-            {
-            }
         };
 
         struct Pass
         {
+            Pass()
+                : m_vertex_shader(nullptr),
+                  m_vertex_shader_info(nullptr),
+                  m_pixel_shader(nullptr),
+                  m_pixel_shader_info(nullptr),
+                  m_vertex_decl{},
+                  m_vertex_decl_asset(nullptr)
+            {
+            }
+
             XAssetInfo<MaterialVertexShader>* m_vertex_shader;
             const d3d9::ShaderInfo* m_vertex_shader_info;
             std::unique_ptr<d3d9::ShaderInfo> m_vertex_shader_info_unq;
@@ -184,21 +194,8 @@ namespace
             MaterialVertexDeclaration m_vertex_decl;
             XAssetInfo<MaterialVertexDeclaration>* m_vertex_decl_asset;
             std::vector<PassShaderArgument> m_arguments;
-
-            Pass()
-                : m_vertex_shader(nullptr),
-                  m_vertex_shader_info(nullptr),
-                  m_pixel_shader(nullptr),
-                  m_pixel_shader_info(nullptr),
-                  m_vertex_decl{},
-                  m_vertex_decl_asset(nullptr)
-            {
-            }
         };
 
-        std::vector<Pass> m_passes;
-        std::vector<XAssetInfoGeneric*> m_dependencies;
-
         TechniqueCreator(
             const std::string& techniqueName, ISearchPath& searchPath, MemoryManager& memory, AssetCreationContext& context, ITechsetCreator* techsetCreator)
             : m_technique_name(techniqueName),
@@ -217,10 +214,11 @@ namespace
             m_passes.emplace_back();
         }
 
-        static size_t RegisterCountPerElement(const d3d9::ShaderConstant& constant)
+        static unsigned RegisterCountPerElement(const d3d9::ShaderConstant& constant)
         {
             const auto valuesPerRegister =
                 constant.m_register_set == d3d9::RegisterSet::BOOL || constant.m_register_set == d3d9::RegisterSet::SAMPLER ? 1u : 4u;
+
             return utils::Align(constant.m_type_columns * constant.m_type_rows, valuesPerRegister) / valuesPerRegister;
         }
 
@@ -243,7 +241,7 @@ namespace
             if (shaderType == techset::ShaderSelector::VERTEX_SHADER && isSamplerArgument)
                 return false;
 
-            MaterialShaderArgument argument{};
+            MaterialShaderArgument argument;
             argument.dest = static_cast<uint16_t>(shaderArgument.m_register_index + registerOffset);
 
             unsigned arrayCount;
@@ -258,7 +256,7 @@ namespace
                     return false;
 
                 argument.type = MTL_ARG_CODE_PIXEL_SAMPLER;
-                argument.u.codeSampler = samplerSource->source + elementOffset;
+                argument.u.codeSampler = samplerSource->source + static_cast<unsigned>(elementOffset);
 
                 arrayCount = static_cast<unsigned>(samplerSource->arrayCount);
             }
@@ -304,13 +302,12 @@ namespace
                     {
                         if (!AutoCreateShaderArgument(techset::ShaderSelector::VERTEX_SHADER, argument, elementIndex, registerIndex))
                         {
-                            std::ostringstream ss;
+                            std::string elementIndexStr;
-                            ss << "Unassigned vertex shader \"" << pass.m_vertex_shader->m_name << "\" arg: " << argument.m_name;
-
                             if (argument.m_type_elements > 1)
-                                ss << '[' << elementIndex << ']';
+                                elementIndexStr = std::format("[{}]", elementIndex);
 
-                            errorMessage = ss.str();
+                            errorMessage =
+                                std::format("Unassigned vertex shader \"{}\" arg: {}{}", pass.m_vertex_shader->m_name, argument.m_name, elementIndexStr);
                             return false;
                         }
                     }
@@ -572,11 +569,11 @@ namespace
             return foundSource;
         }
 
-        bool FindShaderArgument(const d3d9::ShaderInfo& shaderInfo,
+        static bool FindShaderArgument(const d3d9::ShaderInfo& shaderInfo,
-                                const techset::ShaderArgument& argument,
+                                       const techset::ShaderArgument& argument,
-                                size_t& constantIndex,
+                                       size_t& constantIndex,
-                                size_t& registerOffset,
+                                       size_t& registerOffset,
-                                std::string& errorMessage) const
+                                       std::string& errorMessage)
         {
             const auto matchingShaderConstant = std::ranges::find_if(shaderInfo.m_constants,
                                                                      [argument](const d3d9::ShaderConstant& constant)
@@ -854,14 +851,14 @@ namespace
         }
 
         bool AcceptShaderLiteralArgument(const techset::ShaderSelector shader,
-                                         techset::ShaderArgument shaderArgument,
+                                         const techset::ShaderArgument shaderArgument,
-                                         techset::ShaderArgumentLiteralSource source,
+                                         const techset::ShaderArgumentLiteralSource source,
                                          std::string& errorMessage) override
         {
             assert(!m_passes.empty());
             auto& pass = m_passes.at(m_passes.size() - 1);
 
-            MaterialShaderArgument argument{};
+            MaterialShaderArgument argument;
             const d3d9::ShaderInfo* shaderInfo;
 
             if (shader == techset::ShaderSelector::VERTEX_SHADER)
@@ -913,14 +910,14 @@ namespace
         }
 
         bool AcceptShaderMaterialArgument(const techset::ShaderSelector shader,
-                                          techset::ShaderArgument shaderArgument,
+                                          const techset::ShaderArgument shaderArgument,
                                           const techset::ShaderArgumentMaterialSource source,
                                           std::string& errorMessage) override
         {
             assert(!m_passes.empty());
             auto& pass = m_passes.at(m_passes.size() - 1);
 
-            MaterialShaderArgument argument{};
+            MaterialShaderArgument argument;
             const d3d9::ShaderInfo* shaderInfo;
 
             if (shader == techset::ShaderSelector::VERTEX_SHADER)
@@ -1016,6 +1013,8 @@ namespace
             return true;
         }
 
+        std::vector<Pass> m_passes;
+
     private:
         const std::string& m_technique_name;
         ISearchPath& m_search_path;

src/ObjLoading/Game/IW5/Menu/LoaderMenuListIW5.cpp

@@ -83,7 +83,7 @@ namespace
                                    menu::MenuAssetZoneState& zoneState,
                                    MenuConversionZoneState& conversionState,
                                    std::vector<menuDef_t*>& menus,
-                                   AssetRegistration<AssetMenuList>& registration)
+                                   AssetRegistration<AssetMenuList>& registration) const
         {
             const auto alreadyLoadedMenuFile = conversionState.m_menus_by_filename.find(menuFilePath);
             if (alreadyLoadedMenuFile != conversionState.m_menus_by_filename.end())
@@ -125,14 +125,14 @@ namespace
                                   menu::MenuAssetZoneState& zoneState,
                                   MenuConversionZoneState& conversionState,
                                   std::vector<menuDef_t*>& menus,
-                                  AssetRegistration<AssetMenuList>& registration)
+                                  AssetRegistration<AssetMenuList>& registration) const
         {
             const auto menuCount = parsingResult.m_menus.size();
             const auto functionCount = parsingResult.m_functions.size();
             const auto menuLoadCount = parsingResult.m_menus_to_load.size();
             auto totalItemCount = 0u;
             for (const auto& menu : parsingResult.m_menus)
-                totalItemCount += menu->m_items.size();
+                totalItemCount += static_cast<unsigned>(menu->m_items.size());
 
             std::cout << std::format("Successfully read menu file \"{}\" ({} loads, {} menus, {} functions, {} items)\n",
                                      fileName,
@@ -152,7 +152,7 @@ namespace
             // Convert all menus and add them as assets
             for (auto& commonMenu : parsingResult.m_menus)
             {
-                auto converter = IMenuConverter::Create(ObjLoading::Configuration.MenuNoOptimization, m_search_path, m_memory, context);
+                const auto converter = IMenuConverter::Create(ObjLoading::Configuration.MenuNoOptimization, m_search_path, m_memory, context);
 
                 auto* menuAsset = m_memory.Alloc<menuDef_t>();
                 AssetRegistration<AssetMenu> menuRegistration(commonMenu->m_name, menuAsset);
@@ -182,7 +182,7 @@ namespace
             return true;
         }
 
-        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus)
+        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus) const
         {
             menuList.menuCount = static_cast<int>(menus.size());
 
@@ -196,7 +196,8 @@ namespace
                 menuList.menus = nullptr;
         }
 
-        std::unique_ptr<menu::ParsingResult> ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState)
+        std::unique_ptr<menu::ParsingResult>
+            ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState) const
         {
             menu::MenuFileReader reader(stream, menuFileName, menu::FeatureLevel::IW5, m_search_path);
 

src/ObjLoading/Game/IW5/RawFile/LoaderRawFileIW5.cpp

@@ -44,7 +44,7 @@ namespace
             zs.zfree = Z_NULL;
             zs.opaque = Z_NULL;
             zs.avail_in = static_cast<uInt>(file.m_length);
-            zs.avail_out = compressionBufferSize;
+            zs.avail_out = static_cast<unsigned>(compressionBufferSize);
             zs.next_in = reinterpret_cast<const Bytef*>(uncompressedBuffer.get());
             zs.next_out = reinterpret_cast<Bytef*>(compressedBuffer);
 

src/ObjLoading/Game/IW5/Script/LoaderScriptFileIW5.cpp

@@ -57,7 +57,7 @@ namespace
                 return AssetCreationResult::Failure();
             }
 
-            if (offset + (scriptFile->compressedLen + scriptFile->bytecodeLen) > file.m_length)
+            if (offset + static_cast<size_t>(scriptFile->compressedLen + scriptFile->bytecodeLen) > static_cast<size_t>(file.m_length))
             {
                 std::cerr << std::format("Error: Specified length in {} GSC BIN structure exceeds the actual file size\n", assetName);
                 return AssetCreationResult::Failure();

src/ObjLoading/Game/IW5/Weapon/InfoStringLoaderWeaponIW5.cpp

@@ -232,7 +232,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.animOverrides = animOverrides;
-            m_weapon.weapCompleteDef.numAnimOverrides = valueArray.size();
+            m_weapon.weapCompleteDef.numAnimOverrides = static_cast<unsigned>(valueArray.size());
 
             return true;
         }
@@ -267,7 +267,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.soundOverrides = soundOverrides;
-            m_weapon.weapCompleteDef.numSoundOverrides = valueArray.size();
+            m_weapon.weapCompleteDef.numSoundOverrides = static_cast<unsigned>(valueArray.size());
 
             return true;
         }
@@ -305,7 +305,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.fxOverrides = fxOverrides;
-            m_weapon.weapCompleteDef.numFxOverrides = valueArray.size();
+            m_weapon.weapCompleteDef.numFxOverrides = static_cast<unsigned>(valueArray.size());
 
             return true;
         }
@@ -339,7 +339,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.reloadOverrides = reloadOverrides;
-            m_weapon.weapCompleteDef.numReloadStateTimerOverrides = valueArray.size();
+            m_weapon.weapCompleteDef.numReloadStateTimerOverrides = static_cast<unsigned>(valueArray.size());
 
             return true;
         }
@@ -392,7 +392,7 @@ namespace
 
             m_weapon.weapCompleteDef.notetrackOverrides = m_memory.Alloc<NoteTrackToSoundEntry>(overrideVector.size());
             memcpy(m_weapon.weapCompleteDef.notetrackOverrides, overrideVector.data(), sizeof(NoteTrackToSoundEntry) * overrideVector.size());
-            m_weapon.weapCompleteDef.numNotetrackOverrides = overrideVector.size();
+            m_weapon.weapCompleteDef.numNotetrackOverrides = static_cast<unsigned>(overrideVector.size());
 
             return true;
         }
@@ -437,7 +437,7 @@ namespace
             return false;
         }
 
-        void ParseAnim(const std::string& value, const char*& animName)
+        void ParseAnim(const std::string& value, const char*& animName) const
         {
             if (value == "none")
             {
@@ -449,7 +449,7 @@ namespace
             m_registration.AddIndirectAssetReference(m_context.LoadIndirectAssetReference<AssetXAnim>(value));
         }
 
-        void ParseSoundAlias(const std::string& value, SndAliasCustom& soundAlias)
+        void ParseSoundAlias(const std::string& value, SndAliasCustom& soundAlias) const
         {
             if (value == "none")
             {
@@ -462,7 +462,7 @@ namespace
             m_registration.AddIndirectAssetReference(m_context.LoadIndirectAssetReference<AssetSound>(value));
         }
 
-        bool ParseFxEffectDef(const std::string& value, FxEffectDef*& fx)
+        bool ParseFxEffectDef(const std::string& value, FxEffectDef*& fx) const
         {
             if (value == "none")
             {
@@ -542,7 +542,7 @@ namespace
             return true;
         }
 
-        void ParseScriptString(const std::string& value, ScriptString& out)
+        void ParseScriptString(const std::string& value, ScriptString& out) const
         {
             out = m_zone_script_strings.AddOrGetScriptString(value);
             m_registration.AddScriptString(out);
@@ -863,7 +863,7 @@ InfoStringLoaderWeapon::InfoStringLoaderWeapon(MemoryManager& memory, ISearchPat
 {
 }
 
-AssetCreationResult InfoStringLoaderWeapon::CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context)
+AssetCreationResult InfoStringLoaderWeapon::CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context) const
 {
     auto* weaponFullDef = m_memory.Alloc<WeaponFullDef>();
 

src/ObjLoading/Game/IW5/Weapon/InfoStringLoaderWeaponIW5.h

@@ -11,7 +11,7 @@ namespace IW5
     public:
         InfoStringLoaderWeapon(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
 
-        AssetCreationResult CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context);
+        AssetCreationResult CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context) const;
 
     private:
         MemoryManager& m_memory;

src/ObjLoading/Game/T5/RawFile/LoaderRawFileT5.cpp

@@ -40,7 +40,7 @@ namespace
         }
 
     private:
-        AssetCreationResult LoadGsc(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
+        AssetCreationResult LoadGsc(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context) const
         {
             const auto uncompressedBuffer = std::make_unique<char[]>(static_cast<size_t>(file.m_length + 1));
 
@@ -58,7 +58,7 @@ namespace
             zs.zfree = Z_NULL;
             zs.opaque = Z_NULL;
             zs.avail_in = static_cast<uInt>(file.m_length + 1);
-            zs.avail_out = compressionBufferSize;
+            zs.avail_out = static_cast<unsigned>(compressionBufferSize);
             zs.next_in = reinterpret_cast<const Bytef*>(uncompressedBuffer.get());
             zs.next_out = reinterpret_cast<Bytef*>(&compressedBuffer[sizeof(uint32_t) + sizeof(uint32_t)]);
 
@@ -79,7 +79,7 @@ namespace
             const auto compressedSize = compressionBufferSize - zs.avail_out;
 
             reinterpret_cast<uint32_t*>(compressedBuffer)[0] = static_cast<uint32_t>(file.m_length + 1); // outLen
-            reinterpret_cast<uint32_t*>(compressedBuffer)[1] = compressedSize;                           // inLen
+            reinterpret_cast<uint32_t*>(compressedBuffer)[1] = static_cast<uint32_t>(compressedSize);    // inLen
 
             auto* rawFile = m_memory.Alloc<RawFile>();
             rawFile->name = m_memory.Dup(assetName.c_str());
@@ -91,7 +91,7 @@ namespace
             return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, rawFile));
         }
 
-        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
+        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context) const
         {
             auto* rawFile = m_memory.Alloc<RawFile>();
             rawFile->name = m_memory.Dup(assetName.c_str());

src/ObjLoading/Game/T6/FontIcon/LoaderFontIconT6.cpp

@@ -5,9 +5,7 @@
 #include "Game/T6/T6.h"
 
 #include <algorithm>
-#include <cstring>
 #include <format>
-#include <sstream>
 
 using namespace T6;
 
@@ -25,8 +23,8 @@ namespace
     constexpr unsigned ROW_ALIAS_NAME = 2;
     constexpr unsigned ROW_ALIAS_BUTTON = 3;
 
-    constexpr const char* VALUE_TYPE_ICON = "icon";
+    constexpr auto VALUE_TYPE_ICON = "icon";
-    constexpr const char* VALUE_TYPE_ALIAS = "alias";
+    constexpr auto VALUE_TYPE_ALIAS = "alias";
 
     constexpr unsigned COL_COUNT_ICON = 7;
     constexpr unsigned COL_COUNT_ALIAS = 4;
@@ -125,8 +123,8 @@ namespace
                 }
             }
 
-            fontIcon->numEntries = entries.size();
+            fontIcon->numEntries = static_cast<unsigned>(entries.size());
-            fontIcon->numAliasEntries = aliases.size();
+            fontIcon->numAliasEntries = static_cast<unsigned>(aliases.size());
 
             if (fontIcon->numEntries > 0)
             {
@@ -159,7 +157,7 @@ namespace
         {
             for (auto& cell : row)
             {
-                for (auto c : cell)
+                for (const auto c : cell)
                 {
                     if (isspace(c))
                         continue;
@@ -220,7 +218,7 @@ namespace
                          const std::string& assetName,
                          const unsigned rowIndex,
                          AssetCreationContext& context,
-                         AssetRegistration<AssetFontIcon>& registration)
+                         AssetRegistration<AssetFontIcon>& registration) const
         {
             if (row.size() < COL_COUNT_ICON)
             {
@@ -246,6 +244,7 @@ namespace
                 std::cerr << std::format("{} Failed to load material \"{}\"\n", ErrorPrefix(assetName, rowIndex), row[ROW_ICON_MATERIAL]);
                 return false;
             }
+            registration.AddDependency(materialDependency);
 
             icon.fontIconMaterialHandle = materialDependency->Asset();
             icon.fontIconName.string = m_memory.Dup(row[ROW_ICON_NAME].c_str());
@@ -254,7 +253,7 @@ namespace
             return true;
         }
 
-        bool ReadAliasRow(
+        static bool ReadAliasRow(
             const std::vector<std::string>& row, FontIconAlias& alias, const std::string& assetName, const unsigned rowIndex, AssetCreationContext& context)
         {
             if (row.size() < COL_COUNT_ALIAS)

src/ObjLoading/Game/T6/Image/LoaderImageT6.cpp

@@ -32,8 +32,8 @@ namespace
 
             const auto fileSize = static_cast<size_t>(file.m_length);
             const auto fileData = std::make_unique<char[]>(fileSize);
-            file.m_stream->read(fileData.get(), fileSize);
+            file.m_stream->read(fileData.get(), static_cast<std::streamsize>(fileSize));
-            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(fileData.get()), fileSize));
+            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(fileData.get()), static_cast<unsigned>(fileSize)));
 
             std::istringstream ss(std::string(fileData.get(), fileSize));
             const auto texture = iwi::LoadIwi(ss);

src/ObjLoading/Game/T6/RawFile/LoaderRawFileT6.cpp

@@ -58,7 +58,7 @@ namespace
             zs.zfree = Z_NULL;
             zs.opaque = Z_NULL;
             zs.avail_in = static_cast<uInt>(file.m_length);
-            zs.avail_out = compressionBufferSize;
+            zs.avail_out = static_cast<unsigned>(compressionBufferSize);
             zs.next_in = reinterpret_cast<const Bytef*>(uncompressedBuffer.get());
             zs.next_out = reinterpret_cast<Bytef*>(&compressedBuffer[sizeof(uint32_t)]);
 
@@ -92,7 +92,7 @@ namespace
             return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, rawFile));
         }
 
-        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
+        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context) const
         {
             auto* rawFile = m_memory.Alloc<RawFile>();
             rawFile->name = m_memory.Dup(assetName.c_str());

src/ObjLoading/Game/T6/Sound/LoaderSoundBankT6.cpp

@@ -679,7 +679,7 @@ namespace
         if (!aliasList.empty())
             aliasLists.emplace_back(CreateAliasList(aliasList, memory));
 
-        sndBank->aliasCount = aliasLists.size();
+        sndBank->aliasCount = static_cast<unsigned>(aliasLists.size());
         if (sndBank->aliasCount)
         {
             sndBank->alias = memory.Alloc<SndAliasList>(sndBank->aliasCount);
@@ -702,7 +702,7 @@ namespace
             const auto idx = sndBank->alias[i].id % sndBank->aliasCount;
             if (sndBank->aliasIndex[idx].value == std::numeric_limits<unsigned short>::max())
             {
-                sndBank->aliasIndex[idx].value = i;
+                sndBank->aliasIndex[idx].value = static_cast<unsigned short>(i);
                 sndBank->aliasIndex[idx].next = std::numeric_limits<unsigned short>::max();
                 setAliasIndexList[i] = true;
             }
@@ -720,14 +720,14 @@ namespace
             }
 
             auto offset = 1u;
-            auto freeIdx = std::numeric_limits<unsigned short>::max();
+            unsigned short freeIdx;
             while (true)
             {
-                freeIdx = (idx + offset) % sndBank->aliasCount;
+                freeIdx = static_cast<unsigned short>((idx + offset) % sndBank->aliasCount);
                 if (sndBank->aliasIndex[freeIdx].value == std::numeric_limits<unsigned short>::max())
                     break;
 
-                freeIdx = (idx + sndBank->aliasCount - offset) % sndBank->aliasCount;
+                freeIdx = static_cast<unsigned short>((idx + sndBank->aliasCount - offset) % sndBank->aliasCount);
                 if (sndBank->aliasIndex[freeIdx].value == std::numeric_limits<unsigned short>::max())
                     break;
 
@@ -745,7 +745,7 @@ namespace
             }
 
             sndBank->aliasIndex[idx].next = freeIdx;
-            sndBank->aliasIndex[freeIdx].value = i;
+            sndBank->aliasIndex[freeIdx].value = static_cast<unsigned short>(i);
             sndBank->aliasIndex[freeIdx].next = std::numeric_limits<unsigned short>::max();
             setAliasIndexList[i] = true;
         }
@@ -849,7 +849,7 @@ namespace
             radverbs.emplace_back(radverb);
         }
 
-        sndBank->radverbCount = radverbs.size();
+        sndBank->radverbCount = static_cast<unsigned>(radverbs.size());
         if (sndBank->radverbCount)
         {
             sndBank->radverbs = memory.Alloc<SndRadverb>(sndBank->radverbCount);
@@ -912,7 +912,7 @@ namespace
 
             for (auto& valueJson : duckJson["values"])
             {
-                auto index = GetValueIndex(valueJson["duckGroup"].get<std::string>(), SOUND_DUCK_GROUPS, std::extent_v<decltype(SOUND_DUCK_GROUPS)>);
+                const auto index = GetValueIndex(valueJson["duckGroup"].get<std::string>(), SOUND_DUCK_GROUPS, std::extent_v<decltype(SOUND_DUCK_GROUPS)>);
 
                 duck.attenuation[index] = valueJson["attenuation"].get<float>();
                 duck.filter[index] = valueJson["filter"].get<float>();
@@ -921,7 +921,7 @@ namespace
             ducks.emplace_back(duck);
         }
 
-        sndBank->duckCount = ducks.size();
+        sndBank->duckCount = static_cast<unsigned>(ducks.size());
         if (sndBank->duckCount)
         {
             sndBank->ducks = memory.Alloc<SndDuck>(sndBank->duckCount);
@@ -1046,7 +1046,7 @@ namespace
 
                 if (result)
                 {
-                    sndBank->loadedAssets.dataSize = dataSize;
+                    sndBank->loadedAssets.dataSize = static_cast<unsigned>(dataSize);
                     sndBank->loadedAssets.data = m_memory.Alloc<SndChar2048>(dataSize);
                 }
                 else

src/ObjLoading/Game/T6/Weapon/InfoStringLoaderWeaponT6.cpp

@@ -574,12 +574,12 @@ namespace
                     {
                         if (lastSibling == nullptr)
                         {
-                            attachmentUnique.childLink = attachmentUniqueIndex;
+                            attachmentUnique.childLink = static_cast<int>(attachmentUniqueIndex);
                             lastSibling = weapon.attachmentUniques[attachmentUniqueIndex];
                         }
                         else
                         {
-                            lastSibling->siblingLink = attachmentUniqueIndex;
+                            lastSibling->siblingLink = static_cast<int>(attachmentUniqueIndex);
                             lastSibling = weapon.attachmentUniques[attachmentUniqueIndex];
                         }
                     }

src/ObjLoading/Game/T6/Weapon/JsonWeaponCamoLoaderT6.cpp

@@ -151,7 +151,7 @@ namespace
         {
             if (!jWeaponCamoMaterialSet.materials.empty())
             {
-                weaponCamoMaterialSet.numMaterials = jWeaponCamoMaterialSet.materials.size();
+                weaponCamoMaterialSet.numMaterials = static_cast<unsigned>(jWeaponCamoMaterialSet.materials.size());
                 weaponCamoMaterialSet.materials = m_memory.Alloc<WeaponCamoMaterial>(weaponCamoMaterialSet.numMaterials);
 
                 for (auto i = 0u; i < weaponCamoMaterialSet.numMaterials; i++)
@@ -197,7 +197,7 @@ namespace
 
             if (!jWeaponCamo.camoSets.empty())
             {
-                weaponCamo.numCamoSets = jWeaponCamo.camoSets.size();
+                weaponCamo.numCamoSets = static_cast<unsigned>(jWeaponCamo.camoSets.size());
                 weaponCamo.camoSets = m_memory.Alloc<WeaponCamoSet>(weaponCamo.numCamoSets);
 
                 for (auto i = 0u; i < weaponCamo.numCamoSets; i++)
@@ -214,7 +214,7 @@ namespace
 
             if (!jWeaponCamo.camoMaterials.empty())
             {
-                weaponCamo.numCamoMaterials = jWeaponCamo.camoMaterials.size();
+                weaponCamo.numCamoMaterials = static_cast<unsigned>(jWeaponCamo.camoMaterials.size());
                 weaponCamo.camoMaterials = m_memory.Alloc<WeaponCamoMaterialSet>(weaponCamo.numCamoMaterials);
 
                 for (auto i = 0u; i < weaponCamo.numCamoMaterials; i++)

src/ObjLoading/ObjContainer/IPak/IPak.cpp

@@ -56,9 +56,9 @@ namespace
 
         [[nodiscard]] std::unique_ptr<iobjstream> GetEntryStream(const Hash nameHash, const Hash dataHash) const override
         {
-            IPakIndexEntryKey wantedKey{};
+            const IPakIndexEntryKey wantedKey{
-            wantedKey.nameHash = nameHash;
+                {.dataHash = dataHash, .nameHash = nameHash}
-            wantedKey.dataHash = dataHash;
+            };
 
             for (auto& entry : m_index_entries)
             {
@@ -209,5 +209,5 @@ IIPak::Hash IIPak::HashString(const std::string& str)
 
 IIPak::Hash IIPak::HashData(const void* data, const size_t dataSize)
 {
-    return crc32(0, static_cast<const Bytef*>(data), dataSize);
+    return crc32(0, static_cast<const Bytef*>(data), static_cast<unsigned>(dataSize));
 }

src/ObjLoading/ObjContainer/IPak/IPakEntryReadStream.cpp

@@ -2,6 +2,7 @@
 
 #include "ObjContainer/IPak/IPakTypes.h"
 
+#include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <minilzo.h>
@@ -24,7 +25,7 @@ IPakEntryReadStream::IPakEntryReadStream(
       m_current_command_offset(0),
       m_pos(startOffset),
       m_base_pos(startOffset),
-      m_end_pos(startOffset + entrySize),
+      m_end_pos(startOffset + static_cast<int64_t>(entrySize)),
       m_buffer_start_pos(0),
       m_buffer_end_pos(0)
 {
@@ -53,8 +54,7 @@ bool IPakEntryReadStream::SetChunkBufferWindow(const int64_t startPos, size_t ch
 {
     // Cannot load more than IPAK_CHUNK_COUNT_PER_READ chunks without overflowing the buffer
     assert(chunkCount <= IPAK_CHUNK_COUNT_PER_READ);
-    if (chunkCount > IPAK_CHUNK_COUNT_PER_READ)
+    chunkCount = std::min(chunkCount, IPAK_CHUNK_COUNT_PER_READ);
-        chunkCount = IPAK_CHUNK_COUNT_PER_READ;
 
     // The start position must be aligned to IPAK_CHUNK_SIZE
     assert(startPos % IPAK_CHUNK_SIZE == 0);
@@ -66,7 +66,7 @@ bool IPakEntryReadStream::SetChunkBufferWindow(const int64_t startPos, size_t ch
         return true;
     }
 
-    const auto endPos = startPos + static_cast<int64_t>(chunkCount) * IPAK_CHUNK_SIZE;
+    const auto endPos = startPos + static_cast<int64_t>(chunkCount) * static_cast<int64_t>(IPAK_CHUNK_SIZE);
 
     // Check whether the start position is already part of the loaded data
     // We might be able to reuse previously loaded data
@@ -133,7 +133,7 @@ bool IPakEntryReadStream::ValidateBlockHeader(const IPakDataBlockHeader* blockHe
     }
 
     // We expect the current file to be continued where we left off
-    if (blockHeader->countAndOffset.offset != m_file_head)
+    if (static_cast<int64_t>(blockHeader->countAndOffset.offset) != m_file_head)
     {
         // A matching offset is only relevant if a command contains data
         for (unsigned currentCommand = 0; currentCommand < blockHeader->countAndOffset.count; currentCommand++)
@@ -228,7 +228,7 @@ bool IPakEntryReadStream::ProcessCommand(const size_t commandSize, const int com
             m_current_command_buffer = m_decompress_buffer;
             m_current_command_length = outputSize;
             m_current_command_offset = 0;
-            m_file_head += outputSize;
+            m_file_head += static_cast<int64_t>(outputSize);
         }
         else
         {
@@ -240,9 +240,9 @@ bool IPakEntryReadStream::ProcessCommand(const size_t commandSize, const int com
         m_current_command_buffer = &m_chunk_buffer[m_pos - m_buffer_start_pos];
         m_current_command_length = commandSize;
         m_current_command_offset = 0;
-        m_file_head += commandSize;
+        m_file_head += static_cast<int64_t>(commandSize);
     }
-    m_pos += commandSize;
+    m_pos += static_cast<int64_t>(commandSize);
 
     return true;
 }
@@ -326,7 +326,7 @@ std::streambuf::int_type IPakEntryReadStream::uflow()
 std::streamsize IPakEntryReadStream::xsgetn(char* ptr, const std::streamsize count)
 {
     auto* destBuffer = reinterpret_cast<uint8_t*>(ptr);
-    int64_t countRead = 0;
+    std::streamsize countRead = 0;
 
     while (countRead < count)
     {
@@ -337,12 +337,11 @@ std::streamsize IPakEntryReadStream::xsgetn(char* ptr, const std::streamsize cou
         }
 
         auto sizeToRead = count - countRead;
-        if (sizeToRead > m_current_command_length - m_current_command_offset)
+        sizeToRead = std::min(sizeToRead, static_cast<std::streamsize>(m_current_command_length - m_current_command_offset));
-            sizeToRead = m_current_command_length - m_current_command_offset;
 
         if (sizeToRead > 0)
         {
-            assert(static_cast<size_t>(count - countRead) >= static_cast<size_t>(sizeToRead));
+            assert(count - countRead >= sizeToRead);
             memcpy(&destBuffer[countRead], &m_current_command_buffer[m_current_command_offset], static_cast<size_t>(sizeToRead));
             countRead += sizeToRead;
             m_current_command_offset += static_cast<size_t>(sizeToRead);

src/ObjLoading/ObjContainer/SoundBank/SoundBank.cpp

@@ -1,9 +1,9 @@
 #include "SoundBank.h"
 
-#include "Utils/FileUtils.h"
 #include "zlib.h"
 
 #include <cstring>
+#include <format>
 #include <memory>
 #include <sstream>
 #include <vector>
@@ -67,18 +67,18 @@ protected:
 
         if (dir == std::ios_base::end)
         {
-            if (off > m_size)
+            if (off > static_cast<off_type>(m_size))
                 return pos_type(-1);
 
-            return seekpos(m_size - off, mode);
+            return seekpos(static_cast<off_type>(m_size) - off, mode);
         }
 
-        return seekpos(m_offset + off, mode);
+        return seekpos(static_cast<pos_type>(m_offset) + off, mode);
     }
 
     pos_type seekpos(const pos_type pos, std::ios_base::openmode mode) override
     {
-        if (pos < 0 || pos >= m_size)
+        if (pos < 0 || pos >= static_cast<pos_type>(m_size))
             return pos_type(-1);
 
         m_stream.seekg(m_base_offset + pos);
@@ -96,7 +96,7 @@ public:
     {
     }
 
-    _NODISCARD bool is_open() const override
+    [[nodiscard]] bool is_open() const override
     {
         return m_open;
     }
@@ -116,13 +116,13 @@ SoundBankEntryInputStream::SoundBankEntryInputStream()
 
 SoundBankEntryInputStream::SoundBankEntryInputStream(std::unique_ptr<std::istream> stream, SoundAssetBankEntry entry)
     : m_stream(std::move(stream)),
-      m_entry(entry)
+      m_entry(std::move(entry))
 {
 }
 
 bool SoundBankEntryInputStream::IsOpen() const
 {
-    return m_stream.get() != nullptr;
+    return m_stream != nullptr;
 }
 
 bool SoundBank::ReadHeader()
@@ -130,49 +130,50 @@ bool SoundBank::ReadHeader()
     m_stream->read(reinterpret_cast<char*>(&m_header), sizeof(m_header));
     if (m_stream->gcount() != sizeof(m_header))
     {
-        printf("Unexpected eof when trying to load sndbank header.\n");
+        std::cerr << "Unexpected eof when trying to load sndbank header.\n";
         return false;
     }
 
     if (m_header.magic != MAGIC)
     {
-        std::cout << "Invalid sndbank magic 0x" << std::hex << m_header.magic << "\n";
+        std::cerr << std::format("Invalid sndbank magic 0x{:x}\n", m_header.magic);
         return false;
     }
 
     if (m_header.version != VERSION)
     {
-        std::cout << "Unsupported sndbank version " << m_header.version << " (should be " << VERSION << ")\n";
+        std::cerr << std::format("Unsupported sndbank version {} (should be {})\n", m_header.version, VERSION);
         return false;
     }
 
     if (m_header.entrySize != sizeof(SoundAssetBankEntry))
     {
-        std::cout << "Invalid sndbank entry size 0x" << std::hex << m_header.entrySize << " (should be 0x" << std::hex << sizeof(SoundAssetBankEntry) << ")\n";
+        std::cerr << std::format("Invalid sndbank entry size 0x{:x} (should be 0x{:x})\n", m_header.entrySize, sizeof(SoundAssetBankEntry));
         return false;
     }
 
     if (m_header.fileSize != m_file_size)
     {
-        std::cout << "Invalid sndbank " << m_file_size << " (header expects " << m_header.fileSize << ")\n";
+        std::cerr << std::format("Invalid sndbank {} (header expects {})\n", m_file_size, m_header.fileSize);
         return false;
     }
 
-    if (m_header.entryCount && (m_header.entryOffset <= 0 || m_header.entryOffset + sizeof(SoundAssetBankEntry) * m_header.entryCount > m_file_size))
+    if (m_header.entryCount
+        && (m_header.entryOffset <= 0 || m_header.entryOffset + sizeof(SoundAssetBankEntry) * m_header.entryCount > static_cast<size_t>(m_file_size)))
     {
-        std::cout << "Invalid sndbank entry offset " << m_header.entryOffset << " (filesize is " << m_file_size << ")\n";
+        std::cerr << std::format("Invalid sndbank entry offset {} (filesize is {})\n", m_header.entryOffset, m_file_size);
         return false;
     }
 
-    if (m_header.checksumOffset <= 0 || m_header.checksumOffset + sizeof(SoundAssetBankChecksum) * m_header.entryCount > m_file_size)
+    if (m_header.checksumOffset <= 0 || m_header.checksumOffset + sizeof(SoundAssetBankChecksum) * m_header.entryCount > static_cast<size_t>(m_file_size))
     {
-        std::cout << "Invalid sndbank checksum offset " << m_header.checksumOffset << " (filesize is " << m_file_size << ")\n";
+        std::cerr << std::format("Invalid sndbank checksum offset {} (filesize is {})\n", m_header.checksumOffset, m_file_size);
         return false;
     }
 
     if (m_header.dependencyCount * m_header.dependencySize > sizeof(SoundAssetBankHeader::dependencies))
     {
-        std::cout << "Invalid sndbank dependency sizes (count is " << m_header.dependencyCount << "; size is " << m_header.dependencySize << ")\n";
+        std::cerr << std::format("Invalid sndbank dependency sizes (count is {}; size is {})\n", m_header.dependencyCount, m_header.dependencySize);
         return false;
     }
 
@@ -201,13 +202,13 @@ bool SoundBank::ReadEntries()
 
         if (m_stream->gcount() != sizeof(entry))
         {
-            std::cout << "Failed to read sound bank entry at index " << i << "\n";
+            std::cerr << std::format("Failed to read sound bank entry at index {}\n", i);
             return false;
         }
 
         if (entry.offset == 0 || entry.offset + entry.size >= m_file_size)
         {
-            std::cout << "Invalid sound bank entry data offset " << entry.offset << " (filesize is " << m_header.fileSize << ")\n";
+            std::cerr << std::format("Invalid sound bank entry data offset {} (filesize is {})\n", entry.offset, m_header.fileSize);
             return false;
         }
 
@@ -229,7 +230,7 @@ bool SoundBank::ReadChecksums()
 
         if (m_stream->gcount() != sizeof(checksum))
         {
-            std::cout << "Failed to read sound bank checksum at index " << i << "\n";
+            std::cerr << std::format("Failed to read sound bank checksum at index {}\n", i);
             return false;
         }
 

src/ObjLoading/SearchPath/IWD.cpp

@@ -145,7 +145,7 @@ namespace
                 {
                     char temp[1024];
                     const auto toRead = skipAmount > sizeof(temp) ? sizeof(temp) : static_cast<size_t>(skipAmount);
-                    unzReadCurrentFile(m_container, temp, toRead);
+                    unzReadCurrentFile(m_container, temp, static_cast<unsigned>(toRead));
                     skipAmount -= toRead;
                 }
 

src/ObjLoading/StringTable/StringTableLoader.h

@@ -36,8 +36,7 @@ namespace string_table
 
             while (csv.NextRow(currentLine))
             {
-                if (currentLine.size() > maxCols)
+                maxCols = std::max(static_cast<unsigned>(currentLine.size()), maxCols);
-                    maxCols = currentLine.size();
                 csvLines.emplace_back(std::move(currentLine));
                 currentLine = std::vector<std::string>();
             }

src/ObjLoading/Techset/Parsing/Sequence/TechniqueShaderScopeSequences.cpp

@@ -213,7 +213,7 @@ namespace techset
                 const auto& shaderArgumentIndexToken = result.NextCapture(CAPTURE_SHADER_INDEX);
                 if (shaderArgumentIndexToken.IntegerValue() < 0)
                     throw ParsingException(shaderArgumentIndexToken.GetPos(), "Index cannot be negative");
-                const auto index = static_cast<size_t>(shaderArgumentIndexToken.IntegerValue());
+                const auto index = static_cast<unsigned>(shaderArgumentIndexToken.IntegerValue());
                 arg = ShaderArgument(shaderArgumentNameToken.IdentifierValue(), index);
             }
             else

src/ObjLoading/Techset/TechniqueDefinitionAcceptor.cpp

@@ -15,7 +15,7 @@ ShaderArgument::ShaderArgument(std::string argumentName)
 {
 }
 
-ShaderArgument::ShaderArgument(std::string argumentName, const size_t argumentIndex)
+ShaderArgument::ShaderArgument(std::string argumentName, const unsigned argumentIndex)
     : m_argument_name(std::move(argumentName)),
       m_argument_index_specified(true),
       m_argument_index(argumentIndex)
@@ -35,7 +35,7 @@ ShaderArgumentCodeSource::ShaderArgumentCodeSource(std::vector<std::string> acce
 {
 }
 
-ShaderArgumentCodeSource::ShaderArgumentCodeSource(std::vector<std::string> accessors, const size_t indexAccessor)
+ShaderArgumentCodeSource::ShaderArgumentCodeSource(std::vector<std::string> accessors, const unsigned indexAccessor)
     : m_accessors(std::move(accessors)),
       m_index_accessor_specified(true),
       m_index_accessor(indexAccessor)
@@ -102,7 +102,7 @@ ShaderArgumentMaterialSource::ShaderArgumentMaterialSource()
 {
 }
 
-ShaderArgumentMaterialSource::ShaderArgumentMaterialSource(const size_t hash)
+ShaderArgumentMaterialSource::ShaderArgumentMaterialSource(const unsigned hash)
     : m_is_hash(true),
       m_hash(hash)
 {

src/ObjLoading/Techset/TechniqueDefinitionAcceptor.h

@@ -16,11 +16,11 @@ namespace techset
     public:
         std::string m_argument_name;
         bool m_argument_index_specified;
-        size_t m_argument_index;
+        unsigned m_argument_index;
 
         ShaderArgument();
         explicit ShaderArgument(std::string argumentName);
-        ShaderArgument(std::string argumentName, size_t argumentIndex);
+        ShaderArgument(std::string argumentName, unsigned argumentIndex);
     };
 
     class ShaderArgumentCodeSource
@@ -28,11 +28,11 @@ namespace techset
     public:
         std::vector<std::string> m_accessors;
         bool m_index_accessor_specified;
-        size_t m_index_accessor;
+        unsigned m_index_accessor;
 
         ShaderArgumentCodeSource();
         explicit ShaderArgumentCodeSource(std::vector<std::string> accessors);
-        ShaderArgumentCodeSource(std::vector<std::string> accessors, size_t indexAccessor);
+        ShaderArgumentCodeSource(std::vector<std::string> accessors, unsigned indexAccessor);
     };
 
     class ShaderArgumentLiteralSource
@@ -53,13 +53,13 @@ namespace techset
     class ShaderArgumentMaterialSource
     {
     public:
-        bool m_is_hash;
-        size_t m_hash;
-        std::string m_name;
-
         ShaderArgumentMaterialSource();
-        explicit ShaderArgumentMaterialSource(size_t hash);
+        explicit ShaderArgumentMaterialSource(unsigned hash);
         explicit ShaderArgumentMaterialSource(std::string name);
+
+        bool m_is_hash;
+        unsigned m_hash;
+        std::string m_name;
     };
 
     class ITechniqueDefinitionAcceptor

src/ObjLoading/XModel/Gltf/GltfLoader.cpp

@@ -258,7 +258,7 @@ namespace
             VerifyAccessorVertexCount("WEIGHTS_0", weightsAccessor, vertexCount);
             // clang-format on
 
-            const auto vertexOffset = common.m_vertices.size();
+            const auto vertexOffset = static_cast<unsigned>(common.m_vertices.size());
             common.m_vertices.reserve(vertexOffset + vertexCount);
             common.m_vertex_bone_weights.reserve(vertexOffset + vertexCount);
             for (auto vertexIndex = 0u; vertexIndex < vertexCount; vertexIndex++)
@@ -300,6 +300,7 @@ namespace
             }
 
             m_vertex_offset_for_accessors.emplace(accessorsForVertex, vertexOffset);
+
             return vertexOffset;
         }
 
@@ -499,7 +500,7 @@ namespace
             const auto boneInSkin = std::ranges::find(skin.joints, nodeIndex);
             if (boneInSkin == skin.joints.end())
                 throw GltfLoadException("Bone node is not part of skin");
-            const auto boneIndexInSkin = std::distance(skin.joints.begin(), boneInSkin);
+            const auto boneIndexInSkin = static_cast<unsigned>(std::distance(skin.joints.begin(), boneInSkin));
 
             const auto commonBoneOffset = skinBoneOffset + boneIndexInSkin;
             auto& bone = common.m_bones[commonBoneOffset];
@@ -548,7 +549,7 @@ namespace
                 return false;
 
             const auto rootNode = GetRootNodeForSkin(jRoot, skin).value_or(skin.joints[0]);
-            const auto skinBoneOffset = common.m_bones.size();
+            const auto skinBoneOffset = static_cast<unsigned>(common.m_bones.size());
             common.m_bones.resize(skinBoneOffset + skin.joints.size());
 
             constexpr float defaultTranslation[3]{0.0f, 0.0f, 0.0f};

src/ObjLoading/XModel/PartClassificationState.cpp

@@ -72,7 +72,7 @@ bool PartClassificationState::LoadRow(const char** hitLocStart, const char** hit
         return false;
     }
 
-    const auto hitLocNum = std::distance(hitLocStart, foundHitLoc);
+    const auto hitLocNum = static_cast<unsigned>(std::distance(hitLocStart, foundHitLoc));
 
     m_part_classifications.emplace(row[0], hitLocNum);
     return true;

src/ObjLoading/XModel/TangentData.cpp

@@ -11,11 +11,11 @@ void TangentData::CreateTangentData(const XModelCommon& common)
     m_tangents.resize(vertexCount);
     m_binormals.resize(vertexCount);
 
-    auto triCount = 0u;
+    auto triCount = 0uz;
     for (const auto& object : common.m_objects)
         triCount += object.m_faces.size();
 
-    std::vector<uint16_t> indices(triCount * 3u);
+    std::vector<uint16_t> indices(triCount * 3uz);
     auto triOffset = 0u;
     for (const auto& object : common.m_objects)
     {

src/ZoneCommon/Zone/Definition/Parsing/ZoneDefinitionParserState.cpp

@@ -26,14 +26,14 @@ namespace
         if (!maybeObjContainer)
             return;
 
-        maybeObjContainer->m_asset_end = zoneDefinition.m_assets.size();
+        maybeObjContainer->m_asset_end = static_cast<unsigned>(zoneDefinition.m_assets.size());
         zoneDefinition.m_obj_containers.emplace_back(std::move(*maybeObjContainer));
         maybeObjContainer = std::nullopt;
     }
 
     ZoneDefinitionObjContainer DefineNewObjContainer(const ZoneDefinition& zoneDefinition, std::string name, const ZoneDefinitionObjContainerType type)
     {
-        return ZoneDefinitionObjContainer(std::move(name), type, zoneDefinition.m_assets.size());
+        return ZoneDefinitionObjContainer(std::move(name), type, static_cast<unsigned>(zoneDefinition.m_assets.size()));
     }
 
     void SortObjContainer(ZoneDefinition& zoneDefinition)

src/ZoneCommon/Zone/XChunk/XChunkProcessorDeflate.cpp

@@ -17,9 +17,9 @@ size_t XChunkProcessorDeflate::Process(int streamNumber, const uint8_t* input, c
     if (ret != Z_OK)
         throw XChunkException("Initializing deflate failed.");
 
-    stream.avail_in = inputLength;
+    stream.avail_in = static_cast<unsigned>(inputLength);
     stream.next_in = input;
-    stream.avail_out = outputBufferSize;
+    stream.avail_out = static_cast<unsigned>(outputBufferSize);
     stream.next_out = output;
 
     ret = deflate(&stream, Z_FINISH);

src/ZoneCommon/Zone/XChunk/XChunkProcessorInflate.cpp

@@ -16,9 +16,9 @@ size_t XChunkProcessorInflate::Process(int streamNumber, const uint8_t* input, c
     if (ret != Z_OK)
         throw XChunkException("Initializing inflate failed.");
 
-    stream.avail_in = inputLength;
+    stream.avail_in = static_cast<unsigned>(inputLength);
     stream.next_in = input;
-    stream.avail_out = outputBufferSize;
+    stream.avail_out = static_cast<unsigned>(outputBufferSize);
     stream.next_out = output;
 
     ret = inflate(&stream, Z_FULL_FLUSH);