.github/workflows/ci.yaml

@@ -10,9 +10,6 @@ on:
 
 jobs:
   build-test-linux:
-    strategy:
-      matrix:
-        build_arch: [x86, x64]
     runs-on: ubuntu-latest
     container: ubuntu:24.04
     steps:
@@ -38,10 +35,10 @@ jobs:
 
       - name: Build
         working-directory: ${{ github.workspace }}
-        run: make -C build -j$(nproc) config=release_${{ matrix.build_arch }} all
+        run: make -C build -j$(nproc) config=release_x86 all
 
       - name: Test
-        working-directory: ${{ github.workspace }}/build/lib/Release_${{ matrix.build_arch }}/tests
+        working-directory: ${{ github.workspace }}/build/lib/Release_x86/tests
         run: |
           ./ObjCommonTests
           ./ObjCompilingTests
@@ -51,14 +48,6 @@ jobs:
           ./ZoneCommonTests
 
   build-test-windows:
-    strategy:
-      matrix:
-        build_arch: [x86, x64]
-        include:
-          - build_arch: x86
-            msbuild_config: Win32
-          - build_arch: x64
-            msbuild_config: x64
     runs-on: windows-latest
     steps:
       - name: Checkout repository
@@ -77,10 +66,10 @@ jobs:
 
       - name: Build
         working-directory: ${{ github.workspace }}
-        run: msbuild /m /p:Configuration=Release /p:Platform=${{ matrix.msbuild_config }} build
+        run: msbuild /m /p:Configuration=Release /p:Platform=Win32 build
 
       - name: Test
-        working-directory: ${{ github.workspace }}/build/lib/Release_${{ matrix.build_arch }}/tests
+        working-directory: ${{ github.workspace }}/build/lib/Release_x86/tests
         run: |
           $combinedExitCode = 0
           ./ObjCommonTests

premake5.lua

@@ -117,7 +117,7 @@ group ""
 -- Projects
 -- ========================
 include "src/Common.lua"
-include "src/Cryptography.lua"
+include "src/Crypto.lua"
 include "src/ImageConverter.lua"
 include "src/Linker.lua"
 include "src/Parser.lua"
@@ -141,7 +141,7 @@ include "tools/scripts/raw.lua"
 -- Components group: All projects assist or are part of a tool
 group "Components"
     Common:project()
-    Cryptography:project()
+    Crypto:project()
     Parser:project()
     Utils:project()
     ZoneCode:project()

src/Common/Game/IW3/IW3_Assets.h

@@ -135,7 +135,7 @@ namespace IW3
     typedef float vec2_t[2];
     typedef float vec3_t[3];
     typedef float vec4_t[4];
-    typedef tdef_align32(128) unsigned int raw_uint128;
+    typedef tdef_align(128) unsigned int raw_uint128;
 
     struct XModelPiece
     {
@@ -179,7 +179,7 @@ namespace IW3
     };
 
     typedef unsigned char ByteVec[3];
-    typedef tdef_align32(4) unsigned short UShortVec[3];
+    typedef tdef_align(4) unsigned short UShortVec[3];
 
     union XAnimDynamicIndicesTrans
     {
@@ -214,7 +214,7 @@ namespace IW3
         XAnimPartTransData u;
     };
 
-    typedef tdef_align32(4) short XQuat[2];
+    typedef tdef_align(4) short XQuat[2];
 
     union XAnimDynamicIndicesQuat
     {
@@ -360,7 +360,7 @@ namespace IW3
         uint16_t* vertsBlend;
     };
 
-    typedef tdef_align32(16) uint16_t r_index16_t;
+    typedef tdef_align(16) uint16_t r_index16_t;
 
     struct XSurface
     {
@@ -709,7 +709,7 @@ namespace IW3
         MaterialTextureDefInfo u;
     };
 
-    struct gcc_align32(8) GfxDrawSurfFields
+    struct gcc_align(8) GfxDrawSurfFields
     {
         uint64_t objectId : 16;
         uint64_t reflectionProbeIndex : 8;
@@ -724,8 +724,8 @@ namespace IW3
 
     union GfxDrawSurf
     {
-        gcc_align32(8) GfxDrawSurfFields fields;
+        gcc_align(8) GfxDrawSurfFields fields;
-        gcc_align32(8) uint64_t packed;
+        gcc_align(8) uint64_t packed;
     };
 
     enum materialSurfType_t
@@ -1314,9 +1314,9 @@ namespace IW3
     {
         char levelCount;
         char flags;
-        uint16_t dimensions[3];
+        int16_t dimensions[3];
         int format;
-        unsigned int resourceSize;
+        int resourceSize;
         char data[1];
     };
 
@@ -1605,7 +1605,7 @@ namespace IW3
         cLeaf_t leaf;
     };
 
-    struct type_align32(16) cbrush_t
+    struct type_align(16) cbrush_t
     {
         float mins[3];
         int contents;
@@ -1671,7 +1671,7 @@ namespace IW3
 
     typedef unsigned short LeafBrush;
 
-    typedef tdef_align32(16) cbrush_t cbrush_array_t;
+    typedef tdef_align(16) cbrush_t cbrush_array_t;
 
     struct clipMap_t
     {
@@ -2265,7 +2265,7 @@ namespace IW3
         char pad;
     };
 
-    typedef tdef_align32(4) GfxSceneDynModel GfxSceneDynModel4;
+    typedef tdef_align(4) GfxSceneDynModel GfxSceneDynModel4;
 
     struct GfxWorld
     {

src/Common/Game/IW4/IW4_Assets.h

@@ -155,10 +155,10 @@ namespace IW4
         void* data;
     };
 
-    typedef tdef_align32(16) char raw_byte16;
+    typedef tdef_align(16) char raw_byte16;
-    typedef tdef_align32(16) float raw_float16;
+    typedef tdef_align(16) float raw_float16;
     typedef unsigned int raw_uint;
-    typedef tdef_align32(128) unsigned int raw_uint128;
+    typedef tdef_align(128) unsigned int raw_uint128;
     typedef unsigned char cbrushedge_t;
     typedef unsigned short r_index_t;
     typedef float vec2_t[2];
@@ -289,7 +289,7 @@ namespace IW4
     };
 
     typedef unsigned char ByteVec[3];
-    typedef tdef_align32(4) unsigned short UShortVec[3];
+    typedef tdef_align(4) unsigned short UShortVec[3];
 
     union XAnimDynamicFrames
     {
@@ -303,7 +303,7 @@ namespace IW4
         uint16_t _2[1];
     };
 
-    struct type_align32(4) XAnimPartTransFrames
+    struct type_align(4) XAnimPartTransFrames
     {
         float mins[3];
         float size[3];
@@ -330,9 +330,9 @@ namespace IW4
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) short XQuat2[2];
+    typedef tdef_align(4) short XQuat2[2];
 
-    struct type_align32(4) XAnimDeltaPartQuatDataFrames2
+    struct type_align(4) XAnimDeltaPartQuatDataFrames2
     {
         XQuat2* frames;
         XAnimDynamicIndicesQuat2 indices;
@@ -356,7 +356,7 @@ namespace IW4
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) short XQuat[4];
+    typedef tdef_align(4) short XQuat[4];
 
     struct XAnimDeltaPartQuatDataFrames
     {
@@ -489,7 +489,7 @@ namespace IW4
         XSurfaceCollisionTree* collisionTree;
     };
 
-    typedef tdef_align32(16) uint16_t r_index16_t;
+    typedef tdef_align(16) uint16_t r_index16_t;
 
     struct XSurface
     {
@@ -843,7 +843,7 @@ namespace IW4
         unsigned int toolFlags;
     };
 
-    struct gcc_align32(8) GfxDrawSurfFields
+    struct gcc_align(8) GfxDrawSurfFields
     {
         uint64_t objectId : 16;
         uint64_t reflectionProbeIndex : 8;
@@ -860,8 +860,8 @@ namespace IW4
 
     union GfxDrawSurf
     {
-        gcc_align32(8) GfxDrawSurfFields fields;
+        gcc_align(8) GfxDrawSurfFields fields;
-        gcc_align32(8) uint64_t packed;
+        gcc_align(8) uint64_t packed;
     };
 
     // The sort key is translated to a numeric value inside the material templates
@@ -993,7 +993,7 @@ namespace IW4
         GfxStateBits* stateBitsTable;
     };
 
-    struct type_align32(4) GfxImageLoadDef
+    struct type_align(4) GfxImageLoadDef
     {
         char levelCount;
         char pad[3];
@@ -2918,8 +2918,8 @@ namespace IW4
         float linkMaxs[2];
     };
 
-    typedef tdef_align32(128) cbrush_t cbrush_array_t;
+    typedef tdef_align(128) cbrush_t cbrush_array_t;
-    typedef tdef_align32(128) Bounds BoundsArray;
+    typedef tdef_align(128) Bounds BoundsArray;
 
     struct clipMap_t
     {
@@ -3539,7 +3539,7 @@ namespace IW4
         Bounds bounds;
     };
 
-    struct type_align32(4) GfxBrushModel
+    struct type_align(4) GfxBrushModel
     {
         GfxBrushModelWritable writable;
         Bounds bounds;
@@ -3744,8 +3744,8 @@ namespace IW4
         int exponent;
     };
 
-    typedef tdef_align32(128) GfxCellTree GfxCellTree128;
+    typedef tdef_align(128) GfxCellTree GfxCellTree128;
-    typedef tdef_align32(4) GfxSceneDynModel GfxSceneDynModel4;
+    typedef tdef_align(4) GfxSceneDynModel GfxSceneDynModel4;
 
     struct GfxWorld
     {

src/Common/Game/IW5/IW5_Assets.h

@@ -221,9 +221,9 @@ namespace IW5
         };
     };
 
-    typedef tdef_align32(16) char raw_byte16;
+    typedef tdef_align(16) char raw_byte16;
-    typedef tdef_align32(16) float raw_float16;
+    typedef tdef_align(16) float raw_float16;
-    typedef tdef_align32(128) unsigned int raw_uint128;
+    typedef tdef_align(128) unsigned int raw_uint128;
     typedef unsigned char raw_byte;
     typedef unsigned int raw_uint;
     typedef unsigned short r_index_t;
@@ -338,7 +338,7 @@ namespace IW5
     };
 
     typedef unsigned char ByteVec[3];
-    typedef tdef_align32(4) unsigned short UShortVec[3];
+    typedef tdef_align(4) unsigned short UShortVec[3];
 
     union XAnimDynamicFrames
     {
@@ -352,7 +352,7 @@ namespace IW5
         uint16_t _2[1];
     };
 
-    struct type_align32(4) XAnimPartTransFrames
+    struct type_align(4) XAnimPartTransFrames
     {
         float mins[3];
         float size[3];
@@ -379,9 +379,9 @@ namespace IW5
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) short XQuat2[2];
+    typedef tdef_align(4) short XQuat2[2];
 
-    struct type_align32(4) XAnimDeltaPartQuatDataFrames2
+    struct type_align(4) XAnimDeltaPartQuatDataFrames2
     {
         XQuat2* frames;
         XAnimDynamicIndicesQuat2 indices;
@@ -405,7 +405,7 @@ namespace IW5
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) short XQuat[4];
+    typedef tdef_align(4) short XQuat[4];
 
     struct XAnimDeltaPartQuatDataFrames
     {
@@ -543,7 +543,7 @@ namespace IW5
         uint16_t i[3];
     };
 
-    typedef tdef_align32(16) XSurfaceTri XSurfaceTri16;
+    typedef tdef_align(16) XSurfaceTri XSurfaceTri16;
 
     struct XSurface
     {
@@ -653,7 +653,7 @@ namespace IW5
         float quantization;
     };
 
-    struct gcc_align32(8) GfxDrawSurfFields
+    struct gcc_align(8) GfxDrawSurfFields
     {
         uint64_t unused : 1;
         uint64_t primarySortKey : 6;
@@ -671,8 +671,8 @@ namespace IW5
 
     union GfxDrawSurf
     {
-        gcc_align32(8) GfxDrawSurfFields fields;
+        gcc_align(8) GfxDrawSurfFields fields;
-        gcc_align32(8) uint64_t packed;
+        gcc_align(8) uint64_t packed;
     };
 
     enum MaterialGameFlags
@@ -1127,7 +1127,7 @@ namespace IW5
         MaterialTechnique* techniques[54];
     };
 
-    struct type_align32(4) GfxImageLoadDef
+    struct type_align(4) GfxImageLoadDef
     {
         char levelCount;
         char pad[3];
@@ -1339,8 +1339,8 @@ namespace IW5
         unsigned char edgeCount[2][3];
     };
 
-    typedef tdef_align32(128) cbrush_t cbrush_array_t;
+    typedef tdef_align(128) cbrush_t cbrush_array_t;
-    typedef tdef_align32(128) Bounds BoundsArray;
+    typedef tdef_align(128) Bounds BoundsArray;
 
     struct ClipInfo
     {
@@ -2190,7 +2190,7 @@ namespace IW5
         Bounds bounds;
     };
 
-    struct type_align32(4) GfxBrushModel
+    struct type_align(4) GfxBrushModel
     {
         GfxBrushModelWritable writable;
         Bounds bounds;
@@ -2396,7 +2396,7 @@ namespace IW5
         int exponent;
     };
 
-    typedef tdef_align32(128) GfxCellTree GfxCellTree128;
+    typedef tdef_align(128) GfxCellTree GfxCellTree128;
 
     struct GfxWorld
     {
@@ -3446,7 +3446,7 @@ namespace IW5
         SndAliasCustom projIgnitionSound;
     };
 
-    typedef tdef_align32(4) AttSight AttSight4;
+    typedef tdef_align(4) AttSight AttSight4;
 
     struct WeaponAttachment
     {

src/Common/Game/T5/T5_Assets.h

@@ -193,20 +193,20 @@ namespace T5
         void* data;
     };
 
-    typedef tdef_align32(16) char char16;
+    typedef tdef_align(16) char char16;
-    typedef tdef_align32(32) char byte32;
+    typedef tdef_align(32) char byte32;
-    typedef tdef_align32(128) char byte128;
+    typedef tdef_align(128) char byte128;
 
-    typedef tdef_align32(4) char char_align4;
+    typedef tdef_align(4) char char_align4;
-    typedef tdef_align32(128) char char_align128;
+    typedef tdef_align(128) char char_align128;
 
-    typedef tdef_align32(16) char raw_byte16;
+    typedef tdef_align(16) char raw_byte16;
-    typedef tdef_align32(128) char raw_byte128;
+    typedef tdef_align(128) char raw_byte128;
 
-    typedef tdef_align32(128) float float_align128;
+    typedef tdef_align(128) float float_align128;
 
     typedef char cbrushedge_t;
-    typedef tdef_align32(128) unsigned int raw_uint128;
+    typedef tdef_align(128) unsigned int raw_uint128;
 
     typedef uint16_t ScriptString;
 
@@ -350,7 +350,7 @@ namespace T5
     };
 
     typedef unsigned char ByteVec[3];
-    typedef tdef_align32(4) unsigned short UShortVec[3];
+    typedef tdef_align(4) unsigned short UShortVec[3];
 
     union XAnimDynamicFrames
     {
@@ -385,7 +385,7 @@ namespace T5
         XAnimPartTransData u;
     };
 
-    typedef tdef_align32(4) short XQuat[2];
+    typedef tdef_align(4) short XQuat[2];
 
     union XAnimDynamicIndicesQuat
     {
@@ -542,7 +542,7 @@ namespace T5
         uint16_t i[3];
     };
 
-    typedef tdef_align32(16) XSurfaceTri XSurfaceTri16;
+    typedef tdef_align(16) XSurfaceTri XSurfaceTri16;
 
     struct XSurface
     {
@@ -627,7 +627,7 @@ namespace T5
         int sflags;
     };
 
-    struct type_align32(16) BrushWrapper
+    struct type_align(16) BrushWrapper
     {
         vec3_t mins;
         int contents;
@@ -650,7 +650,7 @@ namespace T5
         vec3_t halfLengths;
     };
 
-    typedef tdef_align32(16) PhysGeomInfo PhysGeomInfo16;
+    typedef tdef_align(16) PhysGeomInfo PhysGeomInfo16;
 
     struct PhysGeomList
     {
@@ -713,7 +713,7 @@ namespace T5
         PhysConstraints* physConstraints;
     };
 
-    struct gcc_align32(8) GfxDrawSurfFields
+    struct gcc_align(8) GfxDrawSurfFields
     {
         uint64_t objectId : 16;
         uint64_t fade : 4;
@@ -732,8 +732,8 @@ namespace T5
 
     union GfxDrawSurf
     {
-        gcc_align32(8) GfxDrawSurfFields fields;
+        gcc_align(8) GfxDrawSurfFields fields;
-        gcc_align32(8) uint64_t packed;
+        gcc_align(8) uint64_t packed;
     };
 
     struct MaterialInfo
@@ -1138,7 +1138,7 @@ namespace T5
         SND_ASSET_FLAG_PAD_LOOP_BUFFER = 0x2,
     };
 
-    typedef tdef_align32(2048) char snd_align_char;
+    typedef tdef_align(2048) char snd_align_char;
 
     struct snd_asset
     {
@@ -1164,7 +1164,7 @@ namespace T5
         snd_asset sound;
     };
 
-    typedef tdef_align32(2048) char char_align_2048;
+    typedef tdef_align(2048) char char_align_2048;
 
     struct PrimedSound
     {
@@ -1426,7 +1426,7 @@ namespace T5
         cLeaf_s leaf;
     };
 
-    struct type_align32(16) cbrush_t
+    struct type_align(16) cbrush_t
     {
         float mins[3];
         int contents;
@@ -1935,7 +1935,7 @@ namespace T5
         };
     };
 
-    struct type_align32(16) GfxLight
+    struct type_align(16) GfxLight
     {
         char type;
         char canUseShadowMap;
@@ -2142,7 +2142,7 @@ namespace T5
         char rgb[56][3];
     };
 
-    typedef tdef_align32(4) char aligned_byte_pointer;
+    typedef tdef_align(4) char aligned_byte_pointer;
 
     struct GfxLightGrid
     {
@@ -2220,7 +2220,7 @@ namespace T5
         uint16_t dynEntId;
     };
 
-    typedef tdef_align32(4) GfxSceneDynModel GfxSceneDynModel4;
+    typedef tdef_align(4) GfxSceneDynModel GfxSceneDynModel4;
 
     struct BModelDrawInfo
     {
@@ -2283,7 +2283,7 @@ namespace T5
         int stream2ByteOffset;
     };
 
-    struct type_align32(16) GfxSurface
+    struct type_align(16) GfxSurface
     {
         srfTriangles_t tris;
         Material* material;
@@ -2935,7 +2935,7 @@ namespace T5
         ITEM_TYPE_MENUMODEL = 0x27
     };
 
-    struct type_align32(8) itemDef_s
+    struct type_align(8) itemDef_s
     {
         windowDef_t window;
         int type;
@@ -2949,15 +2949,15 @@ namespace T5
         menuDef_t* parent;
         rectData_s* rectExpData;
         ExpressionStatement visibleExp;
-        gcc_align32(8) uint64_t showBits;
+        gcc_align(8) uint64_t showBits;
-        gcc_align32(8) uint64_t hideBits;
+        gcc_align(8) uint64_t hideBits;
         ExpressionStatement forecolorAExp;
         int ui3dWindowId;
         GenericEventHandler* onEvent;
         UIAnimInfo* animInfo;
     };
 
-    struct type_align32(8) menuDef_t
+    struct type_align(8) menuDef_t
     {
         windowDef_t window;
         const char* font;
@@ -2984,8 +2984,8 @@ namespace T5
         GenericEventHandler* onEvent;
         ItemKeyHandler* onKey;
         ExpressionStatement visibleExp;
-        gcc_align32(8) uint64_t showBits;
+        gcc_align(8) uint64_t showBits;
-        gcc_align32(8) uint64_t hideBits;
+        gcc_align(8) uint64_t hideBits;
         const char* allowedBinding;
         const char* soundName;
         int imageTrack;

src/Common/Game/T6/T6_Assets.h

@@ -10,17 +10,17 @@ namespace T6
 {
 #endif
 
-    typedef tdef_align32(16) char char16;
+    typedef tdef_align(16) char char16;
-    typedef tdef_align32(32) char byte32;
+    typedef tdef_align(32) char byte32;
-    typedef tdef_align32(128) char byte128;
+    typedef tdef_align(128) char byte128;
 
-    typedef tdef_align32(4) char char_align4;
+    typedef tdef_align(4) char char_align4;
-    typedef tdef_align32(128) char char_align128;
+    typedef tdef_align(128) char char_align128;
 
-    typedef tdef_align32(16) char raw_byte16;
+    typedef tdef_align(16) char raw_byte16;
-    typedef tdef_align32(128) char raw_byte128;
+    typedef tdef_align(128) char raw_byte128;
 
-    typedef tdef_align32(128) float float_align128;
+    typedef tdef_align(128) float float_align128;
 
     typedef uint16_t ScriptString;
 
@@ -643,7 +643,7 @@ namespace T6
         float lightingOriginRange;
     };
 
-    struct gcc_align32(8) GfxDrawSurfFields
+    struct gcc_align(8) GfxDrawSurfFields
     {
         uint64_t objectId : 16;
         uint64_t customIndex : 9;
@@ -658,8 +658,8 @@ namespace T6
 
     union GfxDrawSurf
     {
-        gcc_align32(8) GfxDrawSurfFields fields;
+        gcc_align(8) GfxDrawSurfFields fields;
-        gcc_align32(8) uint64_t packed;
+        gcc_align(8) uint64_t packed;
     };
 
     // The sort key is translated to a numeric value inside the material templates
@@ -702,7 +702,7 @@ namespace T6
         MTL_GAMEFLAG_1000 = 0x1000,
     };
 
-    struct type_align32(8) MaterialInfo
+    struct type_align(8) MaterialInfo
     {
         const char* name;
         unsigned int gameFlags;
@@ -735,7 +735,7 @@ namespace T6
         CAMERA_REGION_NONE = CAMERA_REGION_COUNT,
     };
 
-    typedef tdef_align32(8) GfxStateBits GfxStateBitsTable;
+    typedef tdef_align(8) GfxStateBits GfxStateBitsTable;
 
     struct Material
     {
@@ -960,9 +960,9 @@ namespace T6
         unsigned int entryCount;
         unsigned int dependencyCount;
         unsigned int pad32;
-        gcc_align32(8) int64_t fileSize;
+        gcc_align(8) int64_t fileSize;
-        gcc_align32(8) int64_t entryOffset;
+        gcc_align(8) int64_t entryOffset;
-        gcc_align32(8) int64_t checksumOffset;
+        gcc_align(8) int64_t checksumOffset;
         char checksumChecksum[16];
         char dependencies[512];
         char padding[1464];
@@ -970,7 +970,7 @@ namespace T6
 
 #pragma pack(push, 1)
 
-    struct type_align32(2) SndRuntimeAssetBank
+    struct type_align(2) SndRuntimeAssetBank
     {
         const char* zone;
         const char* language;
@@ -985,7 +985,7 @@ namespace T6
 
 #pragma pack(pop)
 
-    typedef tdef_align32(2048) char SndChar2048;
+    typedef tdef_align(2048) char SndChar2048;
 
     struct SndLoadedAssets
     {
@@ -1041,8 +1041,8 @@ namespace T6
     };
 
     typedef unsigned short LeafBrush;
-    typedef tdef_align32(128) cbrush_t cbrush_array_t;
+    typedef tdef_align(128) cbrush_t cbrush_array_t;
-    typedef tdef_align32(128) Bounds BoundsArray;
+    typedef tdef_align(128) Bounds BoundsArray;
 
     struct ClipInfo
     {
@@ -1066,7 +1066,7 @@ namespace T6
         int* brushContents;
     };
 
-    struct type_align32(4) cLeaf_s
+    struct type_align(4) cLeaf_s
     {
         uint16_t firstCollAabbIndex;
         uint16_t collAabbCount;
@@ -1273,8 +1273,8 @@ namespace T6
         void /*ID3D11Buffer*/* indexBuffer;
     };
 
-    typedef tdef_align32(4) char aligned_byte_pointer;
+    typedef tdef_align(4) char aligned_byte_pointer;
-    typedef tdef_align32(4) GfxCompressedLightGridCoeffs GfxCompressedLightGridCoeffs_align4;
+    typedef tdef_align(4) GfxCompressedLightGridCoeffs GfxCompressedLightGridCoeffs_align4;
 
     struct GfxLightGrid
     {
@@ -1323,7 +1323,7 @@ namespace T6
         vec3_t sunFxPosition;
     };
 
-    typedef tdef_align32(4) GfxDrawSurf GfxDrawSurf_align4;
+    typedef tdef_align(4) GfxDrawSurf GfxDrawSurf_align4;
 
     struct GfxWorldDpvsStatic
     {
@@ -1449,7 +1449,7 @@ namespace T6
         int lightingQuality;
     };
 
-    struct type_align32(4) GfxLightImage
+    struct type_align(4) GfxLightImage
     {
         GfxImage* image;
         char samplerState;
@@ -1478,8 +1478,8 @@ namespace T6
     struct FontIcon
     {
         const char* name;
-        unsigned int numEntries;
+        int numEntries;
-        unsigned int numAliasEntries;
+        int numAliasEntries;
         FontIconEntry* fontIconEntry;
         FontIconAlias* fontIconAlias;
     };
@@ -1535,7 +1535,7 @@ namespace T6
         expressionRpn* rpn;
     };
 
-    struct type_align32(8) menuDef_t
+    struct type_align(8) menuDef_t
     {
         windowDef_t window;
         const char* font;
@@ -1562,8 +1562,8 @@ namespace T6
         GenericEventHandler* onEvent;
         ItemKeyHandler* onKey;
         ExpressionStatement visibleExp;
-        gcc_align32(8) uint64_t showBits;
+        gcc_align(8) uint64_t showBits;
-        gcc_align32(8) uint64_t hideBits;
+        gcc_align(8) uint64_t hideBits;
         const char* allowedBinding;
         const char* soundName;
         int imageTrack;
@@ -2753,9 +2753,9 @@ namespace T6
         uint16_t i[3];
     };
 
-    typedef tdef_align32(16) XSurfaceTri XSurfaceTri16;
+    typedef tdef_align(16) XSurfaceTri XSurfaceTri16;
 
-    struct type_align32(16) XSurface
+    struct type_align(16) XSurface
     {
         char tileMode;
         unsigned char vertListCount;
@@ -2783,7 +2783,7 @@ namespace T6
         int surfFlags;
     };
 
-    struct type_align32(4) XBoneInfo
+    struct type_align(4) XBoneInfo
     {
         vec3_t bounds[2];
         vec3_t offset;
@@ -3058,7 +3058,7 @@ namespace T6
     {
     };*/
 
-    struct type_align32(4) GfxImageLoadDef
+    struct type_align(4) GfxImageLoadDef
     {
         char levelCount;
         char flags;
@@ -3104,7 +3104,7 @@ namespace T6
         float returnHighpass;
     };
 
-    typedef tdef_align32(16) float SndFloatAlign16;
+    typedef tdef_align(16) float SndFloatAlign16;
 
     struct SndDuck
     {
@@ -3206,7 +3206,7 @@ namespace T6
         cLeafBrushNodeData_t data;
     };
 
-    struct type_align32(16) cbrush_t
+    struct type_align(16) cbrush_t
     {
         vec3_t mins;
         int contents;
@@ -3352,7 +3352,7 @@ namespace T6
         ROPE_CENTITY_CONSTRAINT = 0x3,
     };
 
-    struct type_align32(4) constraint_t
+    struct type_align(4) constraint_t
     {
         vec3_t p;
         rope_constraint_e type;
@@ -3374,7 +3374,7 @@ namespace T6
         unsigned int frame_index;
     };
 
-    struct type_align32(4) rope_t
+    struct type_align(4) rope_t
     {
         par_t m_particles[25];
         constraint_t m_constraints[30];
@@ -3489,7 +3489,7 @@ namespace T6
         uint16_t infoIndex;
     };
 
-    struct type_align32(4) pathnode_dynamic_t
+    struct type_align(4) pathnode_dynamic_t
     {
         SentientHandle pOwner;
         int iFreeTime;
@@ -3595,7 +3595,7 @@ namespace T6
         };
     };
 
-    struct type_align32(16) GfxLight
+    struct type_align(16) GfxLight
     {
         char type;
         char canUseShadowMap;
@@ -3815,7 +3815,7 @@ namespace T6
     };
 
     // Usually __m128, but that is not portable
-    union gcc_align32(8) custom_m128
+    union gcc_align(8) custom_m128
     {
         float m128_f32[4];
         uint64_t m128_u64[2];
@@ -3836,7 +3836,7 @@ namespace T6
         custom_m128 w;
     };
 
-    struct type_align32(16) SSkinInstance
+    struct type_align(16) SSkinInstance
     {
         union
         {
@@ -3888,7 +3888,7 @@ namespace T6
         int baseIndex;
     };
 
-    struct type_align32(16) GfxSurface
+    struct type_align(16) GfxSurface
     {
         srfTriangles_t tris;
         Material* material;
@@ -3913,7 +3913,7 @@ namespace T6
         uint16_t V2[4];
     };
 
-    struct type_align32(4) GfxStaticModelLmapVertexInfo
+    struct type_align(4) GfxStaticModelLmapVertexInfo
     {
         unsigned int* lmapVertexColors;
         void /*ID3D11Buffer*/* lmapVertexColorsVB;
@@ -4113,7 +4113,7 @@ namespace T6
         void* data;
     };
 
-    struct type_align32(8) itemDef_s
+    struct type_align(8) itemDef_s
     {
         windowDef_t window;
         int type;
@@ -5587,7 +5587,7 @@ namespace T6
         LOCAL_CLIENT_COUNT = 0x1,
     };
 
-    struct type_align32(4) DevGraph
+    struct type_align(4) DevGraph
     {
         vec2_t* knots;
         int* knotCount;
@@ -5609,7 +5609,7 @@ namespace T6
     };
 
     typedef char ByteVec[3];
-    typedef tdef_align32(4) uint16_t UShortVec[3];
+    typedef tdef_align(4) uint16_t UShortVec[3];
 
     union XAnimDynamicFrames
     {
@@ -5623,7 +5623,7 @@ namespace T6
         uint16_t _2[1];
     };
 
-    struct type_align32(4) XAnimPartTransFrames
+    struct type_align(4) XAnimPartTransFrames
     {
         vec3_t mins;
         vec3_t size;
@@ -5650,9 +5650,9 @@ namespace T6
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) int16_t XQuat2[2];
+    typedef tdef_align(4) int16_t XQuat2[2];
 
-    struct type_align32(4) XAnimDeltaPartQuatDataFrames2
+    struct type_align(4) XAnimDeltaPartQuatDataFrames2
     {
         XQuat2* frames;
         XAnimDynamicIndicesDeltaQuat2 indices;
@@ -5676,9 +5676,9 @@ namespace T6
         uint16_t _2[1];
     };
 
-    typedef tdef_align32(4) int16_t XQuat[4];
+    typedef tdef_align(4) int16_t XQuat[4];
 
-    struct type_align32(4) XAnimDeltaPartQuatDataFrames
+    struct type_align(4) XAnimDeltaPartQuatDataFrames
     {
         XQuat* frames;
         XAnimDynamicIndicesDeltaQuat indices;
@@ -5738,7 +5738,7 @@ namespace T6
         vec4_t tvec;
     };
 
-    typedef tdef_align32(16) PhysGeomInfo PhysGeomInfo16;
+    typedef tdef_align(16) PhysGeomInfo PhysGeomInfo16;
 
     struct PhysGeomList
     {
@@ -6295,7 +6295,7 @@ namespace T6
     static_assert(sizeof(SndAliasFlags) == 8);
 #endif
 
-    struct type_align32(4) pathlink_s
+    struct type_align(4) pathlink_s
     {
         float fDist;
         uint16_t nodeNum;
@@ -6404,7 +6404,7 @@ namespace T6
         unsigned int v;
     };
 
-    struct type_align32(4) SSkinVert
+    struct type_align(4) SSkinVert
     {
         half4 pos_bone;
         PackedUnitVec normal;
@@ -6495,7 +6495,7 @@ namespace T6
         } vector;
     };
 
-    struct type_align32(8) dvar_t
+    struct type_align(8) dvar_t
     {
         const char* name;
         const char* description;
@@ -7006,7 +7006,7 @@ namespace T6
         uint16_t triangleBeginIndex;
     };
 
-    struct type_align32(16) BrushWrapper
+    struct type_align(16) BrushWrapper
     {
         vec3_t mins;
         int contents;

src/Common/Utils/TypeAlignment.h

@@ -7,6 +7,9 @@
 #ifdef tdef_align
 #undef tdef_align
 #endif
+#ifdef memb_align
+#undef memb_align
+#endif
 #ifdef gcc_align
 #undef gcc_align
 #endif
@@ -14,44 +17,25 @@
 #ifdef __zonecodegenerator
 #define type_align(x) alignas(x)
 #define tdef_align(x) alignas(x)
+#define memb_align(x) alignas(x)
 #define gcc_align(x)
 #else
 #ifdef __ida
 #define type_align(x) __declspec(align(x))
 #define tdef_align(x) __declspec(align(x))
+#define memb_align(x) __declspec(align(x))
 #define gcc_align(x)
 #else
 #ifdef _MSVC_LANG
 #define type_align(x) __declspec(align(x))
 #define tdef_align(x) __declspec(align(x))
+#define memb_align(x) __declspec(align(x))
 #define gcc_align(x)
 #else
 #define type_align(x) __attribute__((__aligned__(x)))
 #define tdef_align(x)
+#define memb_align(x) __attribute__((__aligned__(x)))
 #define gcc_align(x) __attribute__((__aligned__(x)))
 #endif
 #endif
 #endif
-
-#if defined(__zonecodegenerator) || defined(__ida)
-#define type_align32(x) type_align(x)
-#define tdef_align32(x) tdef_align(x)
-#define gcc_align32(x) gcc_align(x)
-#define type_align64(x) type_align(x)
-#define tdef_align64(x) tdef_align(x)
-#define gcc_align64(x) gcc_align(x)
-#elif defined(ARCH_x86)
-#define type_align32(x) type_align(x)
-#define tdef_align32(x) tdef_align(x)
-#define gcc_align32(x) gcc_align(x)
-#define type_align64(x)
-#define tdef_align64(x)
-#define gcc_align64(x)
-#elif defined(ARCH_x64)
-#define type_align32(x)
-#define tdef_align32(x)
-#define gcc_align32(x)
-#define type_align64(x) type_align(x)
-#define tdef_align64(x) tdef_align(x)
-#define gcc_align64(x) gcc_align(x)
-#endif

src/Common/Zone/ZoneTypes.h

@@ -14,6 +14,6 @@ typedef uint32_t xblock_size_t;
 
 constexpr uint16_t SCR_STRING_MAX = std::numeric_limits<scr_string_t>::max();
 
-typedef unsigned block_t;
+typedef int block_t;
-typedef unsigned asset_type_t;
+typedef int asset_type_t;
 typedef unsigned int zone_priority_t;

src/Crypto.lua

@@ -1,29 +1,29 @@
-Cryptography = {}
+Crypto = {}
 
-function Cryptography:include(includes)
+function Crypto:include(includes)
 	if includes:handle(self:name()) then
 		includedirs {
-			path.join(ProjectFolder(), "Cryptography")
+			path.join(ProjectFolder(), "Crypto")
 		}
 	end
 end
 
-function Cryptography:link(links)
+function Crypto:link(links)
 	links:add(self:name())
 	links:linkto(libtomcrypt)
 	links:linkto(libtommath)
 	links:linkto(salsa20)
 end
 
-function Cryptography:use()
+function Crypto:use()
 	
 end
 
-function Cryptography:name()
+function Crypto:name()
-	return "Cryptography"
+	return "Crypto"
 end
 
-function Cryptography:project()
+function Crypto:project()
 	local folder = ProjectFolder()
 	local includes = Includes:create()
 
@@ -34,8 +34,8 @@ function Cryptography:project()
 		language "C++"
 		
 		files {
-			path.join(folder, "Cryptography/**.h"), 
+			path.join(folder, "Crypto/**.h"), 
-			path.join(folder, "Cryptography/**.cpp") 
+			path.join(folder, "Crypto/**.cpp") 
 		}
 		
 		self:include(includes)

src/Crypto/Crypto.cpp

@@ -0,0 +1,32 @@
+#include "Crypto.h"
+
+#include "Impl/AlgorithmMD5.h"
+#include "Impl/AlgorithmRSA.h"
+#include "Impl/AlgorithmSHA1.h"
+#include "Impl/AlgorithmSHA256.h"
+#include "Impl/AlgorithmSalsa20.h"
+
+std::unique_ptr<IHashFunction> Crypto::CreateMD5()
+{
+    return std::make_unique<AlgorithmMD5>();
+}
+
+std::unique_ptr<IHashFunction> Crypto::CreateSHA1()
+{
+    return std::make_unique<AlgorithmSHA1>();
+}
+
+std::unique_ptr<IHashFunction> Crypto::CreateSHA256()
+{
+    return std::make_unique<AlgorithmSHA256>();
+}
+
+std::unique_ptr<IStreamCipher> Crypto::CreateSalsa20(const uint8_t* keyBytes, const size_t keySize)
+{
+    return std::make_unique<AlgorithmSalsa20>(keyBytes, keySize);
+}
+
+std::unique_ptr<IPublicKeyAlgorithm> Crypto::CreateRSA(const IPublicKeyAlgorithm::HashingAlgorithm hashingAlgorithm, const RSAPaddingMode paddingMode)
+{
+    return std::make_unique<AlgorithmRSA>(hashingAlgorithm, paddingMode);
+}

src/Crypto/Crypto.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "IHashFunction.h"
+#include "IPublicKeyAlgorithm.h"
+#include "IStreamCipher.h"
+
+#include <cstddef>
+#include <memory>
+
+class Crypto
+{
+public:
+    enum class RSAPaddingMode
+    {
+        RSA_PADDING_PKS1,
+        RSA_PADDING_PSS,
+    };
+
+    static std::unique_ptr<IHashFunction> CreateMD5();
+
+    static std::unique_ptr<IHashFunction> CreateSHA1();
+    static std::unique_ptr<IHashFunction> CreateSHA256();
+
+    static std::unique_ptr<IStreamCipher> CreateSalsa20(const uint8_t* keyBytes, size_t keySize);
+
+    static std::unique_ptr<IPublicKeyAlgorithm> CreateRSA(IPublicKeyAlgorithm::HashingAlgorithm hashingAlgorithm, RSAPaddingMode paddingMode);
+};

src/Crypto/IHashFunction.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstddef>
+
+class IHashFunction
+{
+public:
+    virtual ~IHashFunction() = default;
+
+    virtual size_t GetHashSize() = 0;
+    virtual void Init() = 0;
+    virtual void Process(const void* input, size_t inputSize) = 0;
+    virtual void Finish(void* hashBuffer) = 0;
+};

src/Crypto/IPublicKeyAlgorithm.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+class IPublicKeyAlgorithm
+{
+public:
+    enum class HashingAlgorithm
+    {
+        RSA_HASH_SHA256,
+        RSA_HASH_SHA512
+    };
+
+    virtual ~IPublicKeyAlgorithm() = default;
+
+    virtual bool SetKey(const uint8_t* keyData, size_t keySize) = 0;
+
+    // If needed add a signing method
+
+    virtual bool Verify(const uint8_t* signedData, size_t signedDataSize, const uint8_t* signature, size_t signatureSize) = 0;
+};

src/Crypto/IStreamCipher.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+class IStreamCipher
+{
+public:
+    virtual ~IStreamCipher() = default;
+
+    virtual void SetIV(const uint8_t* iv, size_t ivSize) = 0;
+
+    virtual void Process(const void* plainText, void* cipherText, size_t amount) = 0;
+};

src/Crypto/Impl/AlgorithmMD5.cpp

@@ -0,0 +1,64 @@
+#include "AlgorithmMD5.h"
+
+#include "CryptoLibrary.h"
+
+#include <cstdint>
+
+class AlgorithmMD5::AlgorithmMD5Impl
+{
+    hash_state m_state{};
+
+public:
+    AlgorithmMD5Impl()
+    {
+        CryptoLibrary::Init();
+
+        Init();
+    }
+
+    void Init()
+    {
+        md5_init(&m_state);
+    }
+
+    void Process(const void* input, const size_t inputSize)
+    {
+        md5_process(&m_state, static_cast<const uint8_t*>(input), inputSize);
+    }
+
+    void Finish(void* hashBuffer)
+    {
+        md5_done(&m_state, static_cast<uint8_t*>(hashBuffer));
+    }
+};
+
+AlgorithmMD5::AlgorithmMD5()
+{
+    m_impl = new AlgorithmMD5Impl();
+}
+
+AlgorithmMD5::~AlgorithmMD5()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+size_t AlgorithmMD5::GetHashSize()
+{
+    return HASH_SIZE;
+}
+
+void AlgorithmMD5::Init()
+{
+    m_impl->Init();
+}
+
+void AlgorithmMD5::Process(const void* input, const size_t inputSize)
+{
+    m_impl->Process(input, inputSize);
+}
+
+void AlgorithmMD5::Finish(void* hashBuffer)
+{
+    m_impl->Finish(hashBuffer);
+}

src/Crypto/Impl/AlgorithmMD5.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "IHashFunction.h"
+
+class AlgorithmMD5 : public IHashFunction
+{
+    class AlgorithmMD5Impl;
+    AlgorithmMD5Impl* m_impl;
+
+public:
+    static const int HASH_SIZE = 16;
+
+    AlgorithmMD5();
+    ~AlgorithmMD5() override;
+
+    size_t GetHashSize() override;
+
+    void Init() override;
+    void Process(const void* input, size_t inputSize) override;
+    void Finish(void* hashBuffer) override;
+};

src/Crypto/Impl/AlgorithmRSA.cpp

@@ -0,0 +1,119 @@
+#include "AlgorithmRSA.h"
+
+#include "CryptoLibrary.h"
+
+#include <cstring>
+
+class AlgorithmRSA::AlgorithmRSAImpl
+{
+    rsa_key m_key{};
+    HashingAlgorithm m_hash;
+    Crypto::RSAPaddingMode m_padding;
+
+    const ltc_hash_descriptor* GetHashDescriptor() const
+    {
+        switch (m_hash)
+        {
+        case HashingAlgorithm::RSA_HASH_SHA256:
+            return &sha256_desc;
+
+        default:
+        case HashingAlgorithm::RSA_HASH_SHA512:
+            return &sha512_desc;
+        }
+    }
+
+    int GetPaddingMode() const
+    {
+        switch (m_padding)
+        {
+        case Crypto::RSAPaddingMode::RSA_PADDING_PKS1:
+            return LTC_PKCS_1_V1_5;
+
+        default:
+        case Crypto::RSAPaddingMode::RSA_PADDING_PSS:
+            return LTC_PKCS_1_PSS;
+        }
+    }
+
+public:
+    AlgorithmRSAImpl(const HashingAlgorithm hash, const Crypto::RSAPaddingMode padding)
+    {
+        m_hash = hash;
+        m_padding = padding;
+
+        CryptoLibrary::Init();
+    }
+
+    ~AlgorithmRSAImpl() = default;
+
+    AlgorithmRSAImpl(AlgorithmRSAImpl& other) = default;
+    AlgorithmRSAImpl(AlgorithmRSAImpl&& other) = delete;
+
+    AlgorithmRSAImpl& operator=(AlgorithmRSAImpl const& other) = default;
+    AlgorithmRSAImpl& operator=(AlgorithmRSAImpl&& other) = delete;
+
+    bool SetKey(const uint8_t* keyData, const size_t keySize)
+    {
+        return rsa_import(keyData, keySize, &m_key) == CRYPT_OK;
+    }
+
+    bool Verify(const uint8_t* signedData, const size_t signedDataSize, const uint8_t* signature, const size_t signatureSize)
+    {
+        const ltc_hash_descriptor* hashDesc = GetHashDescriptor();
+        const int hashId = register_hash(hashDesc);
+        const int padding = GetPaddingMode();
+
+        int result;
+        rsa_verify_hash_ex(signature, signatureSize, signedData, signedDataSize, padding, hashId, 8, &result, &m_key);
+
+        return result == 1;
+    }
+};
+
+AlgorithmRSA::AlgorithmRSA(const HashingAlgorithm hash, const Crypto::RSAPaddingMode padding)
+{
+    m_impl = new AlgorithmRSAImpl(hash, padding);
+}
+
+AlgorithmRSA::~AlgorithmRSA()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+AlgorithmRSA::AlgorithmRSA(AlgorithmRSA& other)
+{
+    m_impl = new AlgorithmRSAImpl(*other.m_impl);
+}
+
+AlgorithmRSA::AlgorithmRSA(AlgorithmRSA&& other) noexcept
+{
+    m_impl = other.m_impl;
+    other.m_impl = nullptr;
+}
+
+AlgorithmRSA& AlgorithmRSA::operator=(AlgorithmRSA const& other)
+{
+    m_impl = new AlgorithmRSAImpl(*other.m_impl);
+
+    return *this;
+}
+
+AlgorithmRSA& AlgorithmRSA::operator=(AlgorithmRSA&& other) noexcept
+{
+    m_impl = other.m_impl;
+    other.m_impl = nullptr;
+
+    return *this;
+}
+
+bool AlgorithmRSA::SetKey(const uint8_t* keyData, size_t keySize)
+{
+    return m_impl->SetKey(keyData, keySize);
+}
+
+bool AlgorithmRSA::Verify(const uint8_t* signedData, const size_t signedDataSize, const uint8_t* signature, const size_t signatureSize)
+{
+    return m_impl->Verify(signedData, signedDataSize, signature, signatureSize);
+}

src/Crypto/Impl/AlgorithmRSA.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "Crypto.h"
+#include "IPublicKeyAlgorithm.h"
+
+#include <cstdint>
+
+class AlgorithmRSA final : public IPublicKeyAlgorithm
+{
+    class AlgorithmRSAImpl;
+    AlgorithmRSAImpl* m_impl;
+
+public:
+    AlgorithmRSA(HashingAlgorithm hash, Crypto::RSAPaddingMode padding);
+    ~AlgorithmRSA() override;
+
+    AlgorithmRSA(AlgorithmRSA& other);
+    AlgorithmRSA(AlgorithmRSA&& other) noexcept;
+
+    AlgorithmRSA& operator=(AlgorithmRSA const& other);
+    AlgorithmRSA& operator=(AlgorithmRSA&& other) noexcept;
+
+    bool SetKey(const uint8_t* keyData, size_t keySize) override;
+
+    bool Verify(const uint8_t* signedData, size_t signedDataSize, const uint8_t* signature, size_t signatureSize) override;
+};

src/Crypto/Impl/AlgorithmSHA1.cpp

@@ -0,0 +1,64 @@
+#include "AlgorithmSHA1.h"
+
+#include "CryptoLibrary.h"
+
+#include <cstdint>
+
+class AlgorithmSHA1::AlgorithmSHA1Impl
+{
+    hash_state m_state{};
+
+public:
+    AlgorithmSHA1Impl()
+    {
+        CryptoLibrary::Init();
+
+        Init();
+    }
+
+    void Init()
+    {
+        sha1_init(&m_state);
+    }
+
+    void Process(const void* input, const size_t inputSize)
+    {
+        sha1_process(&m_state, static_cast<const uint8_t*>(input), inputSize);
+    }
+
+    void Finish(void* hashBuffer)
+    {
+        sha1_done(&m_state, static_cast<uint8_t*>(hashBuffer));
+    }
+};
+
+AlgorithmSHA1::AlgorithmSHA1()
+{
+    m_impl = new AlgorithmSHA1Impl();
+}
+
+AlgorithmSHA1::~AlgorithmSHA1()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+size_t AlgorithmSHA1::GetHashSize()
+{
+    return HASH_SIZE;
+}
+
+void AlgorithmSHA1::Init()
+{
+    m_impl->Init();
+}
+
+void AlgorithmSHA1::Process(const void* input, const size_t inputSize)
+{
+    m_impl->Process(input, inputSize);
+}
+
+void AlgorithmSHA1::Finish(void* hashBuffer)
+{
+    m_impl->Finish(hashBuffer);
+}

src/Crypto/Impl/AlgorithmSHA1.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "IHashFunction.h"
+
+class AlgorithmSHA1 : public IHashFunction
+{
+    class AlgorithmSHA1Impl;
+    AlgorithmSHA1Impl* m_impl;
+
+public:
+    static const int HASH_SIZE = 20;
+
+    AlgorithmSHA1();
+    ~AlgorithmSHA1() override;
+
+    size_t GetHashSize() override;
+
+    void Init() override;
+    void Process(const void* input, size_t inputSize) override;
+    void Finish(void* hashBuffer) override;
+};

src/Crypto/Impl/AlgorithmSHA256.cpp

@@ -0,0 +1,64 @@
+#include "AlgorithmSHA256.h"
+
+#include "CryptoLibrary.h"
+
+#include <cstdint>
+
+class AlgorithmSHA256::Impl
+{
+    hash_state m_state{};
+
+public:
+    Impl()
+    {
+        CryptoLibrary::Init();
+
+        Init();
+    }
+
+    void Init()
+    {
+        sha256_init(&m_state);
+    }
+
+    void Process(const void* input, const size_t inputSize)
+    {
+        sha256_process(&m_state, static_cast<const uint8_t*>(input), inputSize);
+    }
+
+    void Finish(void* hashBuffer)
+    {
+        sha256_done(&m_state, static_cast<uint8_t*>(hashBuffer));
+    }
+};
+
+AlgorithmSHA256::AlgorithmSHA256()
+{
+    m_impl = new Impl();
+}
+
+AlgorithmSHA256::~AlgorithmSHA256()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+size_t AlgorithmSHA256::GetHashSize()
+{
+    return HASH_SIZE;
+}
+
+void AlgorithmSHA256::Init()
+{
+    m_impl->Init();
+}
+
+void AlgorithmSHA256::Process(const void* input, const size_t inputSize)
+{
+    m_impl->Process(input, inputSize);
+}
+
+void AlgorithmSHA256::Finish(void* hashBuffer)
+{
+    m_impl->Finish(hashBuffer);
+}

src/Crypto/Impl/AlgorithmSHA256.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "IHashFunction.h"
+
+class AlgorithmSHA256 : public IHashFunction
+{
+    class Impl;
+    Impl* m_impl;
+
+public:
+    static const int HASH_SIZE = 32;
+
+    AlgorithmSHA256();
+    ~AlgorithmSHA256() override;
+
+    size_t GetHashSize() override;
+
+    void Init() override;
+    void Process(const void* input, size_t inputSize) override;
+    void Finish(void* hashBuffer) override;
+};

src/Crypto/Impl/AlgorithmSalsa20.cpp

@@ -0,0 +1,89 @@
+#include "AlgorithmSalsa20.h"
+
+#include "salsa20.h"
+
+#include <cassert>
+#include <stdexcept>
+
+class AlgorithmSalsa20::AlgorithmSalsa20Impl
+{
+    salsa20_ctx m_context{};
+
+public:
+    AlgorithmSalsa20Impl(const uint8_t* keyBytes, const size_t keySize)
+    {
+        Salsa20_KeySetup(&m_context, keyBytes, keySize * 8);
+    }
+
+    ~AlgorithmSalsa20Impl() = default;
+
+    AlgorithmSalsa20Impl(AlgorithmSalsa20Impl& other) = default;
+    AlgorithmSalsa20Impl(AlgorithmSalsa20Impl&& other) = delete;
+
+    AlgorithmSalsa20Impl& operator=(AlgorithmSalsa20Impl const& other) = default;
+    AlgorithmSalsa20Impl& operator=(AlgorithmSalsa20Impl&& other) = delete;
+
+    void SetIV(const uint8_t* iv, const size_t ivSize)
+    {
+        assert(ivSize == 8);
+
+        if (ivSize != 8)
+        {
+            throw std::invalid_argument("Salsa20 IV size must be 8");
+        }
+
+        Salsa20_IVSetup(&m_context, iv);
+    }
+
+    void Process(const void* plainText, void* cipherText, const size_t amount)
+    {
+        Salsa20_Encrypt_Bytes(&m_context, static_cast<const uint8_t*>(plainText), static_cast<uint8_t*>(cipherText), amount);
+    }
+};
+
+AlgorithmSalsa20::AlgorithmSalsa20(const uint8_t* keyBytes, const size_t keySize)
+{
+    m_impl = new AlgorithmSalsa20Impl(keyBytes, keySize);
+}
+
+AlgorithmSalsa20::~AlgorithmSalsa20()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+AlgorithmSalsa20::AlgorithmSalsa20(AlgorithmSalsa20& other)
+{
+    m_impl = new AlgorithmSalsa20Impl(*other.m_impl);
+}
+
+AlgorithmSalsa20::AlgorithmSalsa20(AlgorithmSalsa20&& other) noexcept
+{
+    m_impl = other.m_impl;
+    other.m_impl = nullptr;
+}
+
+AlgorithmSalsa20& AlgorithmSalsa20::operator=(AlgorithmSalsa20 const& other)
+{
+    m_impl = new AlgorithmSalsa20Impl(*other.m_impl);
+
+    return *this;
+}
+
+AlgorithmSalsa20& AlgorithmSalsa20::operator=(AlgorithmSalsa20&& other) noexcept
+{
+    m_impl = other.m_impl;
+    other.m_impl = nullptr;
+
+    return *this;
+}
+
+void AlgorithmSalsa20::SetIV(const uint8_t* iv, const size_t ivSize)
+{
+    m_impl->SetIV(iv, ivSize);
+}
+
+void AlgorithmSalsa20::Process(const void* plainText, void* cipherText, const size_t amount)
+{
+    m_impl->Process(plainText, cipherText, amount);
+}

src/Crypto/Impl/AlgorithmSalsa20.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "IStreamCipher.h"
+
+class AlgorithmSalsa20 final : public IStreamCipher
+{
+    class AlgorithmSalsa20Impl;
+    AlgorithmSalsa20Impl* m_impl;
+
+public:
+    AlgorithmSalsa20(const uint8_t* keyBytes, size_t keySize);
+    ~AlgorithmSalsa20() override;
+
+    AlgorithmSalsa20(AlgorithmSalsa20& other);
+    AlgorithmSalsa20(AlgorithmSalsa20&& other) noexcept;
+
+    AlgorithmSalsa20& operator=(AlgorithmSalsa20 const& other);
+    AlgorithmSalsa20& operator=(AlgorithmSalsa20&& other) noexcept;
+
+    void SetIV(const uint8_t* iv, size_t ivSize) override;
+    void Process(const void* plainText, void* cipherText, size_t amount) override;
+};

src/Crypto/Impl/Base64.cpp

@@ -20,9 +20,8 @@ namespace base64
 
     bool EncodeBase64(const void* inputData, const size_t inputLength, void* outputBuffer, const size_t outputBufferSize)
     {
-        unsigned long outLength = static_cast<unsigned long>(outputBufferSize);
+        unsigned long outLength = outputBufferSize;
-        const auto result =
+        const auto result = base64_encode(static_cast<const unsigned char*>(inputData), inputLength, static_cast<char*>(outputBuffer), &outLength);
-            base64_encode(static_cast<const unsigned char*>(inputData), static_cast<unsigned long>(inputLength), static_cast<char*>(outputBuffer), &outLength);
         return result == CRYPT_OK;
     }
 
@@ -33,13 +32,12 @@ namespace base64
 
     size_t DecodeBase64(const void* base64Data, const size_t inputLength, void* outputBuffer, const size_t outputBufferSize)
     {
-        auto outLength = static_cast<unsigned long>(GetBase64DecodeOutputLength(base64Data, inputLength));
+        unsigned long outLength = GetBase64DecodeOutputLength(base64Data, inputLength);
         assert(outLength <= outputBufferSize);
         if (outLength > outputBufferSize)
             return 0u;
 
-        const auto result =
+        const auto result = base64_decode(static_cast<const char*>(base64Data), inputLength, static_cast<unsigned char*>(outputBuffer), &outLength);
-            base64_decode(static_cast<const char*>(base64Data), static_cast<unsigned long>(inputLength), static_cast<unsigned char*>(outputBuffer), &outLength);
         assert(result == CRYPT_OK);
 
         return static_cast<size_t>(outLength);

src/Crypto/Impl/Base64.h

@@ -8,6 +8,6 @@ namespace base64
     size_t GetBase64EncodeOutputLength(size_t inputLength);
 
     size_t DecodeBase64(const void* base64Data, size_t inputLength, void* outputBuffer, size_t outputBufferSize);
-    size_t GetBase64DecodeOutputLength(const void* base64Data, size_t inputLength);
+    size_t GetBase64DecodeOutputLength(const void* base64Data, const size_t inputLength);
     size_t GetBase64DecodeOutputLength(size_t inputLength);
 } // namespace base64

src/Crypto/Impl/CryptoLibrary.cpp

@@ -0,0 +1,15 @@
+#include "CryptoLibrary.h"
+
+#include "tommath.h"
+
+void CryptoLibrary::Init()
+{
+    static bool initialized = false;
+
+    if (!initialized)
+    {
+        initialized = true;
+
+        ltc_mp = ltm_desc;
+    }
+}

src/Crypto/Impl/CryptoLibrary.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#define LTC_NO_PROTOTYPES
+#include "tomcrypt.h"
+
+class CryptoLibrary
+{
+public:
+    static void Init();
+};

src/Cryptography/Algorithms/AlgorithmMd5.cpp

@@ -1,54 +0,0 @@
-#include "AlgorithmMd5.h"
-
-#include "Internal/CryptoLibrary.h"
-
-#include <cstdint>
-
-using namespace cryptography;
-
-namespace
-{
-    constexpr int HASH_SIZE = 16;
-
-    class AlgorithmMd5 final : public IHashFunction
-    {
-    public:
-        AlgorithmMd5()
-        {
-            internal::CryptoLibrary::Init();
-
-            Init();
-        }
-
-        size_t GetHashSize() override
-        {
-            return HASH_SIZE;
-        }
-
-        void Init() override
-        {
-            md5_init(&m_state);
-        }
-
-        void Process(const void* input, const size_t inputSize) override
-        {
-            md5_process(&m_state, static_cast<const uint8_t*>(input), static_cast<unsigned long>(inputSize));
-        }
-
-        void Finish(void* hashBuffer) override
-        {
-            md5_done(&m_state, static_cast<uint8_t*>(hashBuffer));
-        }
-
-    private:
-        hash_state m_state{};
-    };
-} // namespace
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateMd5()
-    {
-        return std::make_unique<AlgorithmMd5>();
-    }
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmMd5.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "IHashFunction.h"
-
-#include <memory>
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateMd5();
-}

src/Cryptography/Algorithms/AlgorithmRsa.cpp

@@ -1,84 +0,0 @@
-#include "AlgorithmRsa.h"
-
-#include "Internal/CryptoLibrary.h"
-
-using namespace cryptography;
-
-namespace
-{
-    class AlgorithmRsa final : public IPublicKeyAlgorithm
-    {
-    public:
-        AlgorithmRsa(const HashingAlgorithm hash, const RsaPaddingMode padding)
-        {
-            m_hash = hash;
-            m_padding = padding;
-
-            internal::CryptoLibrary::Init();
-        }
-
-        bool SetKey(const uint8_t* keyData, const size_t keySize) override
-        {
-            return rsa_import(keyData, static_cast<unsigned long>(keySize), &m_key) == CRYPT_OK;
-        }
-
-        bool Verify(const uint8_t* signedData, const size_t signedDataSize, const uint8_t* signature, const size_t signatureSize) override
-        {
-            const ltc_hash_descriptor* hashDesc = GetHashDescriptor();
-            const int hashId = register_hash(hashDesc);
-            const int padding = GetPaddingMode();
-
-            int result;
-            rsa_verify_hash_ex(signature,
-                               static_cast<unsigned long>(signatureSize),
-                               signedData,
-                               static_cast<unsigned long>(signedDataSize),
-                               padding,
-                               hashId,
-                               8,
-                               &result,
-                               &m_key);
-
-            return result == 1;
-        }
-
-    private:
-        [[nodiscard]] const ltc_hash_descriptor* GetHashDescriptor() const
-        {
-            switch (m_hash)
-            {
-            case HashingAlgorithm::RSA_HASH_SHA256:
-                return &sha256_desc;
-
-            default:
-            case HashingAlgorithm::RSA_HASH_SHA512:
-                return &sha512_desc;
-            }
-        }
-
-        [[nodiscard]] int GetPaddingMode() const
-        {
-            switch (m_padding)
-            {
-            case RsaPaddingMode::RSA_PADDING_PKS1:
-                return LTC_PKCS_1_V1_5;
-
-            default:
-            case RsaPaddingMode::RSA_PADDING_PSS:
-                return LTC_PKCS_1_PSS;
-            }
-        }
-
-        rsa_key m_key{};
-        HashingAlgorithm m_hash;
-        RsaPaddingMode m_padding;
-    };
-} // namespace
-
-namespace cryptography
-{
-    std::unique_ptr<IPublicKeyAlgorithm> CreateRsa(const HashingAlgorithm hashingAlgorithm, const RsaPaddingMode paddingMode)
-    {
-        return std::make_unique<AlgorithmRsa>(hashingAlgorithm, paddingMode);
-    }
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmRsa.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "IPublicKeyAlgorithm.h"
-
-#include <cstdint>
-#include <memory>
-
-namespace cryptography
-{
-    enum class RsaPaddingMode : std::uint8_t
-    {
-        RSA_PADDING_PKS1,
-        RSA_PADDING_PSS,
-    };
-
-    std::unique_ptr<IPublicKeyAlgorithm> CreateRsa(HashingAlgorithm hashingAlgorithm, RsaPaddingMode paddingMode);
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmSalsa20.cpp

@@ -1,46 +0,0 @@
-#include "AlgorithmSalsa20.h"
-
-#include "salsa20.h"
-
-#include <cassert>
-#include <stdexcept>
-
-using namespace cryptography;
-
-namespace
-{
-    class AlgorithmSalsa20 final : public IStreamCipher
-    {
-    public:
-        AlgorithmSalsa20(const uint8_t* keyBytes, const size_t keySize)
-        {
-            Salsa20_KeySetup(&m_context, keyBytes, static_cast<uint32_t>(keySize * 8uz));
-        }
-
-        void SetIv(const uint8_t* iv, const size_t ivSize) override
-        {
-            assert(ivSize == 8);
-
-            if (ivSize != 8)
-                throw std::invalid_argument("Salsa20 IV size must be 8");
-
-            Salsa20_IVSetup(&m_context, iv);
-        }
-
-        void Process(const void* plainText, void* cipherText, const size_t amount) override
-        {
-            Salsa20_Encrypt_Bytes(&m_context, static_cast<const uint8_t*>(plainText), static_cast<uint8_t*>(cipherText), static_cast<uint32_t>(amount));
-        }
-
-    private:
-        salsa20_ctx m_context{};
-    };
-} // namespace
-
-namespace cryptography
-{
-    std::unique_ptr<IStreamCipher> CreateSalsa20(const uint8_t* keyBytes, const size_t keySize)
-    {
-        return std::make_unique<AlgorithmSalsa20>(keyBytes, keySize);
-    }
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmSalsa20.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "IStreamCipher.h"
-
-#include <memory>
-
-namespace cryptography
-{
-    std::unique_ptr<IStreamCipher> CreateSalsa20(const uint8_t* keyBytes, size_t keySize);
-}

src/Cryptography/Algorithms/AlgorithmSha1.cpp

@@ -1,54 +0,0 @@
-#include "AlgorithmSha1.h"
-
-#include "Internal/CryptoLibrary.h"
-
-#include <cstdint>
-
-using namespace cryptography;
-
-namespace
-{
-    constexpr int HASH_SIZE = 20;
-
-    class AlgorithmSha1 final : public IHashFunction
-    {
-    public:
-        AlgorithmSha1()
-        {
-            internal::CryptoLibrary::Init();
-
-            Init();
-        }
-
-        size_t GetHashSize() override
-        {
-            return HASH_SIZE;
-        }
-
-        void Init() override
-        {
-            sha1_init(&m_state);
-        }
-
-        void Process(const void* input, const size_t inputSize) override
-        {
-            sha1_process(&m_state, static_cast<const uint8_t*>(input), static_cast<unsigned long>(inputSize));
-        }
-
-        void Finish(void* hashBuffer) override
-        {
-            sha1_done(&m_state, static_cast<uint8_t*>(hashBuffer));
-        }
-
-    private:
-        hash_state m_state{};
-    };
-} // namespace
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateSha1()
-    {
-        return std::make_unique<AlgorithmSha1>();
-    }
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmSha1.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "IHashFunction.h"
-
-#include <memory>
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateSha1();
-}

src/Cryptography/Algorithms/AlgorithmSha256.cpp

@@ -1,54 +0,0 @@
-#include "AlgorithmSha256.h"
-
-#include "Internal/CryptoLibrary.h"
-
-#include <cstdint>
-
-using namespace cryptography;
-
-namespace
-{
-    constexpr int HASH_SIZE = 32;
-
-    class AlgorithmSha256 final : public IHashFunction
-    {
-    public:
-        AlgorithmSha256()
-        {
-            internal::CryptoLibrary::Init();
-
-            Init();
-        }
-
-        size_t GetHashSize() override
-        {
-            return HASH_SIZE;
-        }
-
-        void Init() override
-        {
-            sha256_init(&m_state);
-        }
-
-        void Process(const void* input, const size_t inputSize) override
-        {
-            sha256_process(&m_state, static_cast<const uint8_t*>(input), static_cast<unsigned long>(inputSize));
-        }
-
-        void Finish(void* hashBuffer) override
-        {
-            sha256_done(&m_state, static_cast<uint8_t*>(hashBuffer));
-        }
-
-    private:
-        hash_state m_state{};
-    };
-} // namespace
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateSha256()
-    {
-        return std::make_unique<AlgorithmSha256>();
-    }
-} // namespace cryptography

src/Cryptography/Algorithms/AlgorithmSha256.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "IHashFunction.h"
-
-#include <memory>
-
-namespace cryptography
-{
-    std::unique_ptr<IHashFunction> CreateSha256();
-}

src/Cryptography/Cryptography.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#include "Algorithms/AlgorithmMd5.h"
-#include "Algorithms/AlgorithmRsa.h"
-#include "Algorithms/AlgorithmSalsa20.h"
-#include "Algorithms/AlgorithmSha1.h"
-#include "Algorithms/AlgorithmSha256.h"

src/Cryptography/IHashFunction.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <cstdlib>
-
-namespace cryptography
-{
-    class IHashFunction
-    {
-    public:
-        IHashFunction() = default;
-        virtual ~IHashFunction() = default;
-        IHashFunction(const IHashFunction& other) = default;
-        IHashFunction(IHashFunction&& other) noexcept = default;
-        IHashFunction& operator=(const IHashFunction& other) = default;
-        IHashFunction& operator=(IHashFunction&& other) noexcept = default;
-
-        virtual size_t GetHashSize() = 0;
-        virtual void Init() = 0;
-        virtual void Process(const void* input, size_t inputSize) = 0;
-        virtual void Finish(void* hashBuffer) = 0;
-    };
-} // namespace cryptography

src/Cryptography/IPublicKeyAlgorithm.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstdlib>
-
-namespace cryptography
-{
-    enum class HashingAlgorithm : std::uint8_t
-    {
-        RSA_HASH_SHA256,
-        RSA_HASH_SHA512
-    };
-
-    class IPublicKeyAlgorithm
-    {
-    public:
-        IPublicKeyAlgorithm() = default;
-        virtual ~IPublicKeyAlgorithm() = default;
-        IPublicKeyAlgorithm(const IPublicKeyAlgorithm& other) = default;
-        IPublicKeyAlgorithm(IPublicKeyAlgorithm&& other) noexcept = default;
-        IPublicKeyAlgorithm& operator=(const IPublicKeyAlgorithm& other) = default;
-        IPublicKeyAlgorithm& operator=(IPublicKeyAlgorithm&& other) noexcept = default;
-
-        virtual bool SetKey(const uint8_t* keyData, size_t keySize) = 0;
-
-        // If needed, add a signing method
-
-        virtual bool Verify(const uint8_t* signedData, size_t signedDataSize, const uint8_t* signature, size_t signatureSize) = 0;
-    };
-} // namespace cryptography

src/Cryptography/IStreamCipher.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstdlib>
-
-namespace cryptography
-{
-    class IStreamCipher
-    {
-    public:
-        IStreamCipher() = default;
-        virtual ~IStreamCipher() = default;
-        IStreamCipher(const IStreamCipher& other) = default;
-        IStreamCipher(IStreamCipher&& other) noexcept = default;
-        IStreamCipher& operator=(const IStreamCipher& other) = default;
-        IStreamCipher& operator=(IStreamCipher&& other) noexcept = default;
-
-        virtual void SetIv(const uint8_t* iv, size_t ivSize) = 0;
-        virtual void Process(const void* plainText, void* cipherText, size_t amount) = 0;
-    };
-} // namespace cryptography

src/Cryptography/Internal/CryptoLibrary.cpp

@@ -1,18 +0,0 @@
-#include "CryptoLibrary.h"
-
-#include "tommath.h"
-
-namespace cryptography::internal
-{
-    void CryptoLibrary::Init()
-    {
-        static bool initialized = false;
-
-        if (!initialized)
-        {
-            initialized = true;
-
-            ltc_mp = ltm_desc;
-        }
-    }
-} // namespace cryptography::internal

src/Cryptography/Internal/CryptoLibrary.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#define LTC_NO_PROTOTYPES
-#include "tomcrypt.h"
-
-namespace cryptography::internal
-{
-    class CryptoLibrary
-    {
-    public:
-        static void Init();
-    };
-} // namespace cryptography::internal

src/Linker/LinkerPaths.cpp

@@ -56,8 +56,8 @@ namespace
         void CreateFromString(const std::string& templateString)
         {
             const auto templateStringLength = templateString.size();
-            auto partStart = 0uz;
+            auto partStart = 0u;
-            for (auto i = 0uz; i < templateStringLength; i++)
+            for (auto i = 0u; i < templateStringLength; i++)
             {
                 if (templateString[i] != '?')
                     continue;

src/ObjCommon/Csv/CsvHeaderRow.cpp

@@ -21,7 +21,7 @@ bool CsvHeaderRow::RequireIndexForHeader(const std::string& headerName, unsigned
     if (existingHeader == m_header_row.end())
         return false;
 
-    out = static_cast<unsigned>(std::distance(m_header_row.begin(), existingHeader));
+    out = std::distance(m_header_row.begin(), existingHeader);
     return true;
 }
 

src/ObjCommon/Csv/CsvHeaderRow.h

@@ -13,7 +13,7 @@ public:
 
     bool Read(const CsvInputStream& inputStream);
 
-    [[nodiscard]] const std::string& HeaderNameForColumn(unsigned columnIndex) const;
+    const std::string& HeaderNameForColumn(unsigned columnIndex) const;
     bool RequireIndexForHeader(const std::string& headerName, unsigned& out) const;
     [[nodiscard]] std::optional<unsigned> GetIndexForHeader(const std::string& headerName) const;
 

src/ObjCommon/StructuredDataDef/CommonStructuredDataEnum.cpp

@@ -42,14 +42,14 @@ uint32_t CommonStructuredDataEnum::CalculateChecksum(const uint32_t initialValue
 {
     auto checksum = initialValue;
 
-    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), static_cast<unsigned>(m_name.size() + 1u));
+    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), m_name.size() + 1);
 
     const auto littleEndianElementCount = endianness::ToLittleEndian(ElementCount());
     checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianElementCount), sizeof(littleEndianElementCount));
 
     for (const auto& entry : m_entries)
     {
-        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(entry.m_name.c_str()), static_cast<unsigned>(entry.m_name.size() + 1));
+        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(entry.m_name.c_str()), entry.m_name.size() + 1);
 
         const auto littleEndianValue = endianness::ToLittleEndian(entry.m_value);
         checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianValue), sizeof(littleEndianValue));

src/ObjCommon/StructuredDataDef/CommonStructuredDataStruct.cpp

@@ -41,10 +41,10 @@ uint32_t CommonStructuredDataStruct::CalculateChecksum(const CommonStructuredDat
 {
     auto checksum = initialValue;
 
-    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), static_cast<unsigned>(m_name.size() + 1u));
+    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), m_name.size() + 1);
     for (const auto& property : m_properties)
     {
-        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(property.m_name.c_str()), static_cast<unsigned>(property.m_name.size() + 1u));
+        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(property.m_name.c_str()), property.m_name.size() + 1);
 
         const auto littleEndianOffset = endianness::ToLittleEndian(property.m_offset_in_bits);
         checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianOffset), sizeof(littleEndianOffset));
@@ -68,7 +68,7 @@ uint32_t CommonStructuredDataStruct::CalculateChecksum(const CommonStructuredDat
                 if (currentType.m_info.type_index < def.m_enums.size())
                 {
                     const auto& _enum = *def.m_enums[currentType.m_info.type_index];
-                    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), static_cast<unsigned>(_enum.m_name.size() + 1u));
+                    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), _enum.m_name.size() + 1);
                     currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
                 }
                 break;
@@ -76,7 +76,7 @@ uint32_t CommonStructuredDataStruct::CalculateChecksum(const CommonStructuredDat
                 if (currentType.m_info.type_index < def.m_structs.size())
                 {
                     const auto& _struct = *def.m_structs[currentType.m_info.type_index];
-                    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_struct.m_name.c_str()), static_cast<unsigned>(_struct.m_name.size() + 1u));
+                    checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_struct.m_name.c_str()), _struct.m_name.size() + 1);
                     currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
                 }
                 break;
@@ -99,7 +99,7 @@ uint32_t CommonStructuredDataStruct::CalculateChecksum(const CommonStructuredDat
                     if (enumedArray.m_enum_index < def.m_enums.size())
                     {
                         const auto& _enum = *def.m_enums[enumedArray.m_enum_index];
-                        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), static_cast<unsigned>(_enum.m_name.size() + 1u));
+                        checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), _enum.m_name.size() + 1);
                     }
                     currentType = enumedArray.m_array_type;
                 }

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
 {
-    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;
+
+    CommonStructuredDataStructProperty();
+    explicit CommonStructuredDataStructProperty(std::string name);
+    CommonStructuredDataStructProperty(std::string name, CommonStructuredDataType type, size_t offsetInBits);
 };
 
 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/ObjCompiling/Game/IW3/ObjCompilerIW3.cpp

@@ -11,7 +11,7 @@ namespace
 {
     void ConfigureCompilers(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // No compilers yet
     }
@@ -23,7 +23,7 @@ namespace
                                  ZoneAssetCreationStateContainer& zoneStates,
                                  IOutputPath& outDir)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
             collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, zoneStates, outDir));

src/ObjCompiling/Game/IW4/ObjCompilerIW4.cpp

@@ -11,7 +11,7 @@ namespace
 {
     void ConfigureCompilers(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // No compilers yet
     }
@@ -23,7 +23,7 @@ namespace
                                  ZoneAssetCreationStateContainer& zoneStates,
                                  IOutputPath& outDir)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
             collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, zoneStates, outDir));

src/ObjCompiling/Game/IW5/ObjCompilerIW5.cpp

@@ -11,7 +11,7 @@ namespace
 {
     void ConfigureCompilers(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // No compilers yet
     }
@@ -23,7 +23,7 @@ namespace
                                  ZoneAssetCreationStateContainer& zoneStates,
                                  IOutputPath& outDir)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
             collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, zoneStates, outDir));

src/ObjCompiling/Game/T5/ObjCompilerT5.cpp

@@ -11,7 +11,7 @@ namespace
 {
     void ConfigureCompilers(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // No compilers yet
     }
@@ -23,7 +23,7 @@ namespace
                                  ZoneAssetCreationStateContainer& zoneStates,
                                  IOutputPath& outDir)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
             collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, zoneStates, outDir));

src/ObjCompiling/Game/T6/KeyValuePairs/KeyValuePairsCompilerT6.cpp

@@ -6,6 +6,7 @@
 
 #include <cassert>
 #include <format>
+#include <iostream>
 
 using namespace T6;
 
@@ -41,7 +42,7 @@ namespace
 
             auto* gameKvps = m_memory.Alloc<KeyValuePairs>();
             gameKvps->name = m_memory.Dup(m_zone.m_name.c_str());
-            gameKvps->numVariables = static_cast<unsigned>(commonKvps.size());
+            gameKvps->numVariables = commonKvps.size();
             gameKvps->keyValuePairs = m_memory.Alloc<KeyValuePair>(commonKvps.size());
 
             const auto namespaceHash = Common::Com_HashKey(m_zone.m_name.c_str(), 64);

src/ObjCompiling/Game/T6/ObjCompilerT6.cpp

@@ -17,7 +17,7 @@ namespace
                             ISearchPath& searchPath,
                             ZoneAssetCreationStateContainer& zoneStates)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddAssetCreator(CreateKeyValuePairsCompiler(memory, zone, zoneDefinition.m_zone_definition, zoneStates));
     }
@@ -29,7 +29,7 @@ namespace
                                  ZoneAssetCreationStateContainer& zoneStates,
                                  IOutputPath& outDir)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         if (ImageIPakPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
             collection.AddAssetPostProcessor(std::make_unique<ImageIPakPostProcessor<AssetImage>>(zoneDefinition, searchPath, zoneStates, outDir));

src/ObjCompiling/Image/IPak/IPakCreator.cpp

@@ -1,6 +1,7 @@
 #include "IPakCreator.h"
 
 #include "Game/T6/CommonT6.h"
+#include "Game/T6/GameT6.h"
 #include "GitVersion.h"
 #include "ObjContainer/IPak/IPakTypes.h"
 #include "Utils/Alignment.h"
@@ -22,7 +23,7 @@ namespace
         static constexpr char BRANDING[] = "Created with OpenAssetTools " GIT_VERSION;
         static constexpr auto SECTION_COUNT = 3; // Index + Data + Branding
 
-        inline static const auto PAD_DATA = std::string(256, '\xA7');
+        inline static const std::string PAD_DATA = std::string(256, '\xA7');
 
     public:
         IPakWriter(std::ostream& stream, ISearchPath& searchPath, const std::vector<std::string>& images)
@@ -69,8 +70,8 @@ namespace
 
         void Write(const void* data, const size_t dataSize)
         {
-            m_stream.write(static_cast<const char*>(data), static_cast<std::streamsize>(dataSize));
+            m_stream.write(static_cast<const char*>(data), dataSize);
-            m_current_offset += static_cast<int64_t>(dataSize);
+            m_current_offset += dataSize;
         }
 
         void Pad(const size_t paddingSize)
@@ -99,30 +100,27 @@ namespace
         {
             GoTo(0);
 
-            const IPakHeader header{.magic = ipak_consts::IPAK_MAGIC,
+            const IPakHeader header{ipak_consts::IPAK_MAGIC, ipak_consts::IPAK_VERSION, static_cast<uint32_t>(m_total_size), SECTION_COUNT};
-                                    .version = ipak_consts::IPAK_VERSION,
-                                    .size = static_cast<uint32_t>(m_total_size),
-                                    .sectionCount = SECTION_COUNT};
 
             const IPakSection dataSection{
-                .type = ipak_consts::IPAK_DATA_SECTION,
+                ipak_consts::IPAK_DATA_SECTION,
-                .offset = static_cast<uint32_t>(m_data_section_offset),
+                static_cast<uint32_t>(m_data_section_offset),
-                .size = static_cast<uint32_t>(m_data_section_size),
+                static_cast<uint32_t>(m_data_section_size),
-                .itemCount = static_cast<uint32_t>(m_index_entries.size()),
+                static_cast<uint32_t>(m_index_entries.size()),
             };
 
             const IPakSection indexSection{
-                .type = ipak_consts::IPAK_INDEX_SECTION,
+                ipak_consts::IPAK_INDEX_SECTION,
-                .offset = static_cast<uint32_t>(m_index_section_offset),
+                static_cast<uint32_t>(m_index_section_offset),
-                .size = static_cast<uint32_t>(sizeof(IPakIndexEntry) * m_index_entries.size()),
+                static_cast<uint32_t>(sizeof(IPakIndexEntry) * m_index_entries.size()),
-                .itemCount = static_cast<uint32_t>(m_index_entries.size()),
+                static_cast<uint32_t>(m_index_entries.size()),
             };
 
             const IPakSection brandingSection{
-                .type = ipak_consts::IPAK_BRANDING_SECTION,
+                ipak_consts::IPAK_BRANDING_SECTION,
-                .offset = static_cast<uint32_t>(m_branding_section_offset),
+                static_cast<uint32_t>(m_branding_section_offset),
-                .size = std::extent_v<decltype(BRANDING)>,
+                std::extent_v<decltype(BRANDING)>,
-                .itemCount = 1,
+                1,
             };
 
             Write(&header, sizeof(header));
@@ -149,7 +147,7 @@ namespace
 
             imageSize = static_cast<size_t>(openFile.m_length);
             auto imageData = std::make_unique<char[]>(imageSize);
-            openFile.m_stream->read(imageData.get(), static_cast<std::streamsize>(imageSize));
+            openFile.m_stream->read(imageData.get(), imageSize);
 
             return imageData;
         }
@@ -179,7 +177,7 @@ namespace
                 IPakDataBlockHeader skipBlockHeader{};
                 skipBlockHeader.countAndOffset.count = 1;
                 skipBlockHeader.commands[0].compressed = ipak_consts::IPAK_COMMAND_SKIP;
-                skipBlockHeader.commands[0].size = static_cast<uint32_t>(sizeToSkip - sizeof(IPakDataBlockHeader));
+                skipBlockHeader.commands[0].size = sizeToSkip - sizeof(IPakDataBlockHeader);
                 Write(&skipBlockHeader, sizeof(skipBlockHeader));
             }
 
@@ -201,12 +199,12 @@ namespace
             m_current_block.countAndOffset.offset = static_cast<uint32_t>(m_file_offset);
 
             // Reserve space to later write actual block header data
-            GoTo(static_cast<int64_t>(m_current_offset + sizeof(IPakDataBlockHeader)));
+            GoTo(m_current_offset + sizeof(IPakDataBlockHeader));
         }
 
         void WriteChunkData(const void* data, const size_t dataSize)
         {
-            auto dataOffset = 0uz;
+            auto dataOffset = 0u;
             while (dataOffset < dataSize)
             {
                 if (m_current_block.countAndOffset.count >= std::extent_v<decltype(IPakDataBlockHeader::commands)>)
@@ -227,7 +225,7 @@ namespace
                     continue;
                 }
 
-                const auto commandSize = std::min({remainingSize, ipak_consts::IPAK_COMMAND_DEFAULT_SIZE, remainingChunkBufferWindowSize});
+                const auto commandSize = std::min(std::min(remainingSize, ipak_consts::IPAK_COMMAND_DEFAULT_SIZE), remainingChunkBufferWindowSize);
 
                 auto writeUncompressed = true;
                 if (USE_IPAK_COMPRESSION)
@@ -256,7 +254,7 @@ namespace
                     Write(&static_cast<const char*>(data)[dataOffset], commandSize);
 
                     const auto currentCommand = m_current_block.countAndOffset.count;
-                    m_current_block.commands[currentCommand].size = static_cast<uint32_t>(commandSize);
+                    m_current_block.commands[currentCommand].size = commandSize;
                     m_current_block.commands[currentCommand].compressed = ipak_consts::IPAK_COMMAND_UNCOMPRESSED;
                     m_current_block.countAndOffset.count = currentCommand + 1u;
                 }
@@ -283,7 +281,7 @@ namespace
                 return;
 
             const auto nameHash = T6::Common::R_HashString(imageName.c_str(), 0);
-            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(imageData.get()), static_cast<unsigned>(imageSize)));
+            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(imageData.get()), imageSize));
 
             StartNewFile();
             const auto startOffset = m_current_block_header_offset;
@@ -296,7 +294,7 @@ namespace
             WriteChunkData(imageData.get(), imageSize);
             const auto writtenImageSize = static_cast<size_t>(m_current_offset - startOffset);
 
-            indexEntry.size = static_cast<uint32_t>(writtenImageSize);
+            indexEntry.size = writtenImageSize;
             m_index_entries.emplace_back(indexEntry);
         }
 

src/ObjImage/Image/DdsLoader.cpp

@@ -14,28 +14,16 @@ namespace dds
     {
         static constexpr auto DDS_MAGIC = FileUtils::MakeMagic32('D', 'D', 'S', ' ');
 
-    public:
+        std::istream& m_stream;
-        explicit DdsLoaderInternal(std::istream& stream)
-            : m_stream(stream),
-              m_texture_type(TextureType::T_2D),
-              m_has_mip_maps(false),
-              m_width(0u),
-              m_height(0u),
-              m_depth(0u),
-              m_format(nullptr)
-        {
-        }
 
-        std::unique_ptr<Texture> LoadDds()
+        TextureType m_texture_type;
-        {
+        bool m_has_mip_maps;
-            if (!ReadMagic() || !ReadHeader())
+        size_t m_width;
-                return nullptr;
+        size_t m_height;
+        size_t m_depth;
+        const ImageFormat* m_format;
 
-            return ReadTextureData();
+        _NODISCARD bool ReadMagic() const
-        }
-
-    private:
-        [[nodiscard]] bool ReadMagic() const
         {
             uint32_t magic;
             m_stream.read(reinterpret_cast<char*>(&magic), sizeof(magic));
@@ -54,7 +42,7 @@ namespace dds
             return true;
         }
 
-        [[nodiscard]] bool ReadDxt10Header()
+        _NODISCARD bool ReadDxt10Header()
         {
             DDS_HEADER_DXT10 headerDx10{};
             m_stream.read(reinterpret_cast<char*>(&headerDx10), sizeof(headerDx10));
@@ -98,7 +86,7 @@ namespace dds
             return false;
         }
 
-        [[nodiscard]] bool ReadPixelFormatFourCc(DDS_PIXELFORMAT& pf)
+        _NODISCARD bool ReadPixelFormatFourCc(DDS_PIXELFORMAT& pf)
         {
             switch (pf.dwFourCC)
             {
@@ -144,7 +132,7 @@ namespace dds
             }
         }
 
-        [[nodiscard]] bool ReadPixelFormatUnsigned(DDS_PIXELFORMAT& pf)
+        _NODISCARD bool ReadPixelFormatUnsigned(DDS_PIXELFORMAT& pf)
         {
             unsigned rOffset, rSize, gOffset, gSize, bOffset, bSize, aOffset, aSize;
 
@@ -175,7 +163,7 @@ namespace dds
             return false;
         }
 
-        [[nodiscard]] bool ReadPixelFormat(DDS_PIXELFORMAT& pf)
+        _NODISCARD bool ReadPixelFormat(DDS_PIXELFORMAT& pf)
         {
             if (pf.dwFlags & DDPF_FOURCC)
                 return ReadPixelFormatFourCc(pf);
@@ -212,7 +200,7 @@ namespace dds
             return ReadPixelFormat(header.ddspf);
         }
 
-        [[nodiscard]] std::unique_ptr<Texture> ReadTextureData() const
+        _NODISCARD std::unique_ptr<Texture> ReadTextureData() const
         {
             std::unique_ptr<Texture> result;
 
@@ -241,7 +229,7 @@ namespace dds
 
             for (auto mipLevel = 0; mipLevel < mipMapCount; mipLevel++)
             {
-                const auto mipSize = static_cast<std::streamsize>(result->GetSizeOfMipLevel(mipLevel));
+                const auto mipSize = result->GetSizeOfMipLevel(mipLevel);
 
                 for (auto face = 0; face < faceCount; face++)
                 {
@@ -258,14 +246,25 @@ namespace dds
             return result;
         }
 
-        std::istream& m_stream;
+    public:
+        explicit DdsLoaderInternal(std::istream& stream)
+            : m_stream(stream),
+              m_texture_type(TextureType::T_2D),
+              m_has_mip_maps(false),
+              m_width(0u),
+              m_height(0u),
+              m_depth(0u),
+              m_format(nullptr)
+        {
+        }
 
-        TextureType m_texture_type;
+        std::unique_ptr<Texture> LoadDds()
-        bool m_has_mip_maps;
+        {
-        unsigned m_width;
+            if (!ReadMagic() || !ReadHeader())
-        unsigned m_height;
+                return nullptr;
-        unsigned m_depth;
+
-        const ImageFormat* m_format;
+            return ReadTextureData();
+        }
     };
 
     std::unique_ptr<Texture> LoadDds(std::istream& stream)

src/ObjImage/Image/DdsWriter.cpp

@@ -55,7 +55,7 @@ public:
         {
             const auto* buffer = m_texture->GetBufferForMipLevel(mipLevel);
             const auto mipLevelSize = m_texture->GetSizeOfMipLevel(mipLevel) * m_texture->GetFaceCount();
-            m_stream.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(mipLevelSize));
+            m_stream.write(reinterpret_cast<const char*>(buffer), mipLevelSize);
         }
     }
 
@@ -153,7 +153,7 @@ public:
         header.dwHeight = m_texture->GetHeight();
         header.dwWidth = m_texture->GetWidth();
         header.dwDepth = m_texture->GetDepth();
-        header.dwPitchOrLinearSize = static_cast<uint32_t>(m_texture->GetFormat()->GetPitch(0, m_texture->GetWidth()));
+        header.dwPitchOrLinearSize = m_texture->GetFormat()->GetPitch(0, m_texture->GetWidth());
         header.dwMipMapCount = m_texture->HasMipMaps() ? m_texture->GetMipMapCount() : 1;
 
         PopulatePixelFormat(header.ddspf);

src/ObjImage/Image/Dx12TextureLoader.cpp

@@ -14,7 +14,7 @@ Dx12TextureLoader::Dx12TextureLoader()
 
 const ImageFormat* Dx12TextureLoader::GetFormatForDx12Format() const
 {
-    for (const auto* i : ImageFormat::ALL_FORMATS)
+    for (auto i : ImageFormat::ALL_FORMATS)
     {
         if (i->GetDxgiFormat() == m_format)
             return i;
@@ -41,19 +41,19 @@ Dx12TextureLoader& Dx12TextureLoader::HasMipMaps(const bool hasMipMaps)
     return *this;
 }
 
-Dx12TextureLoader& Dx12TextureLoader::Width(const unsigned width)
+Dx12TextureLoader& Dx12TextureLoader::Width(const size_t width)
 {
     m_width = width;
     return *this;
 }
 
-Dx12TextureLoader& Dx12TextureLoader::Height(const unsigned height)
+Dx12TextureLoader& Dx12TextureLoader::Height(const size_t height)
 {
     m_height = height;
     return *this;
 }
 
-Dx12TextureLoader& Dx12TextureLoader::Depth(const unsigned depth)
+Dx12TextureLoader& Dx12TextureLoader::Depth(const size_t depth)
 {
     m_depth = depth;
     return *this;

src/ObjImage/Image/Dx12TextureLoader.h

@@ -2,6 +2,8 @@
 
 #include "Image/DxgiFormat.h"
 #include "Image/Texture.h"
+#include "Utils/ClassUtils.h"
+#include "Utils/MemoryManager.h"
 
 #include <memory>
 #include <unordered_map>
@@ -14,21 +16,21 @@ public:
     Dx12TextureLoader& Format(oat::DXGI_FORMAT format);
     Dx12TextureLoader& Type(TextureType textureType);
     Dx12TextureLoader& HasMipMaps(bool hasMipMaps);
-    Dx12TextureLoader& Width(unsigned width);
+    Dx12TextureLoader& Width(size_t width);
-    Dx12TextureLoader& Height(unsigned height);
+    Dx12TextureLoader& Height(size_t height);
-    Dx12TextureLoader& Depth(unsigned depth);
+    Dx12TextureLoader& Depth(size_t depth);
 
     std::unique_ptr<Texture> LoadTexture(const void* data);
 
 private:
-    [[nodiscard]] const ImageFormat* GetFormatForDx12Format() const;
+    _NODISCARD const ImageFormat* GetFormatForDx12Format() const;
 
     static std::unordered_map<ImageFormatId, ImageFormatId> m_conversion_table;
 
     oat::DXGI_FORMAT m_format;
     TextureType m_type;
     bool m_has_mip_maps;
-    unsigned m_width;
+    size_t m_width;
-    unsigned m_height;
+    size_t m_height;
-    unsigned m_depth;
+    size_t m_depth;
 };

src/ObjImage/Image/Dx9TextureLoader.cpp

@@ -41,19 +41,19 @@ Dx9TextureLoader& Dx9TextureLoader::HasMipMaps(const bool hasMipMaps)
     return *this;
 }
 
-Dx9TextureLoader& Dx9TextureLoader::Width(const unsigned width)
+Dx9TextureLoader& Dx9TextureLoader::Width(const size_t width)
 {
     m_width = width;
     return *this;
 }
 
-Dx9TextureLoader& Dx9TextureLoader::Height(const unsigned height)
+Dx9TextureLoader& Dx9TextureLoader::Height(const size_t height)
 {
     m_height = height;
     return *this;
 }
 
-Dx9TextureLoader& Dx9TextureLoader::Depth(const unsigned depth)
+Dx9TextureLoader& Dx9TextureLoader::Depth(const size_t depth)
 {
     m_depth = depth;
     return *this;

src/ObjImage/Image/Dx9TextureLoader.h

@@ -2,8 +2,11 @@
 
 #include "Image/D3DFormat.h"
 #include "Image/Texture.h"
+#include "Utils/ClassUtils.h"
+#include "Utils/MemoryManager.h"
 
 #include <memory>
+#include <unordered_map>
 
 class Dx9TextureLoader
 {
@@ -13,19 +16,19 @@ public:
     Dx9TextureLoader& Format(oat::D3DFORMAT format);
     Dx9TextureLoader& Type(TextureType textureType);
     Dx9TextureLoader& HasMipMaps(bool hasMipMaps);
-    Dx9TextureLoader& Width(unsigned width);
+    Dx9TextureLoader& Width(size_t width);
-    Dx9TextureLoader& Height(unsigned height);
+    Dx9TextureLoader& Height(size_t height);
-    Dx9TextureLoader& Depth(unsigned depth);
+    Dx9TextureLoader& Depth(size_t depth);
 
     std::unique_ptr<Texture> LoadTexture(const void* data);
 
 private:
-    [[nodiscard]] const ImageFormat* GetFormatForDx9Format() const;
+    _NODISCARD const ImageFormat* GetFormatForDx9Format() const;
 
     oat::D3DFORMAT m_format;
     TextureType m_type;
     bool m_has_mip_maps;
-    unsigned m_width;
+    size_t m_width;
-    unsigned m_height;
+    size_t m_height;
-    unsigned m_depth;
+    size_t m_depth;
 };

src/ObjImage/Image/ImageFormat.h

@@ -48,13 +48,13 @@ protected:
 public:
     virtual ~ImageFormat() = default;
 
-    [[nodiscard]] ImageFormatId GetId() const;
+    ImageFormatId GetId() const;
-    [[nodiscard]] oat::D3DFORMAT GetD3DFormat() const;
+    oat::D3DFORMAT GetD3DFormat() const;
-    [[nodiscard]] oat::DXGI_FORMAT GetDxgiFormat() const;
+    oat::DXGI_FORMAT GetDxgiFormat() const;
 
-    [[nodiscard]] virtual ImageFormatType GetType() const = 0;
+    virtual ImageFormatType GetType() const = 0;
-    [[nodiscard]] virtual size_t GetPitch(unsigned mipLevel, unsigned width) const = 0;
+    virtual size_t GetPitch(unsigned mipLevel, unsigned width) const = 0;
-    [[nodiscard]] virtual size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const = 0;
+    virtual size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const = 0;
 
     static const ImageFormatUnsigned FORMAT_R8_G8_B8;
     static const ImageFormatUnsigned FORMAT_B8_G8_R8_X8;
@@ -98,14 +98,14 @@ public:
                         unsigned aOffset,
                         unsigned aSize);
 
-    [[nodiscard]] ImageFormatType GetType() const override;
+    ImageFormatType GetType() const override;
-    [[nodiscard]] size_t GetPitch(unsigned mipLevel, unsigned width) const override;
+    size_t GetPitch(unsigned mipLevel, unsigned width) const override;
-    [[nodiscard]] size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const override;
+    size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const override;
 
-    [[nodiscard]] bool HasR() const;
+    bool HasR() const;
-    [[nodiscard]] bool HasG() const;
+    bool HasG() const;
-    [[nodiscard]] bool HasB() const;
+    bool HasB() const;
-    [[nodiscard]] bool HasA() const;
+    bool HasA() const;
 };
 
 class ImageFormatBlockCompressed final : public ImageFormat
@@ -116,7 +116,7 @@ public:
 
     ImageFormatBlockCompressed(ImageFormatId id, oat::D3DFORMAT d3dFormat, oat::DXGI_FORMAT dxgiFormat, unsigned blockSize, unsigned bitsPerBlock);
 
-    [[nodiscard]] ImageFormatType GetType() const override;
+    ImageFormatType GetType() const override;
-    [[nodiscard]] size_t GetPitch(unsigned mipLevel, unsigned width) const override;
+    size_t GetPitch(unsigned mipLevel, unsigned width) const override;
-    [[nodiscard]] size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const override;
+    size_t GetSizeOfMipLevel(unsigned mipLevel, unsigned width, unsigned height, unsigned depth) const override;
 };

src/ObjImage/Image/IwiWriter13.cpp

@@ -110,20 +110,20 @@ void IwiWriter::DumpImage(std::ostream& stream, const Texture* texture)
         currentFileSize += mipLevelSize;
 
         if (currentMipLevel < static_cast<int>(std::extent_v<decltype(IwiHeader::fileSizeForPicmip)>))
-            header.fileSizeForPicmip[currentMipLevel] = static_cast<uint32_t>(currentFileSize);
+            header.fileSizeForPicmip[currentMipLevel] = currentFileSize;
     }
 
-    if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
+    if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
     {
-        FillHeader3D(header, *texture3D);
+        FillHeader2D(header, *texture2D);
     }
     else if (const auto* textureCube = dynamic_cast<const TextureCube*>(texture))
     {
         FillHeaderCube(header, *textureCube);
     }
-    else if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
+    else if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
     {
-        FillHeader2D(header, *texture2D);
+        FillHeader3D(header, *texture3D);
     }
     else
     {

src/ObjImage/Image/IwiWriter27.cpp

@@ -113,20 +113,20 @@ void IwiWriter::DumpImage(std::ostream& stream, const Texture* texture)
         currentFileSize += mipLevelSize;
 
         if (currentMipLevel < static_cast<int>(std::extent_v<decltype(iwi27::IwiHeader::fileSizeForPicmip)>))
-            header.fileSizeForPicmip[currentMipLevel] = static_cast<uint32_t>(currentFileSize);
+            header.fileSizeForPicmip[currentMipLevel] = currentFileSize;
     }
 
-    if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
+    if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
     {
-        FillHeader3D(header, *texture3D);
+        FillHeader2D(header, *texture2D);
     }
     else if (const auto* textureCube = dynamic_cast<const TextureCube*>(texture))
     {
         FillHeaderCube(header, *textureCube);
     }
-    else if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
+    else if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
     {
-        FillHeader2D(header, *texture2D);
+        FillHeader3D(header, *texture3D);
     }
     else
     {

src/ObjImage/Image/IwiWriter6.cpp

@@ -105,20 +105,20 @@ void IwiWriter::DumpImage(std::ostream& stream, const Texture* texture)
         currentFileSize += mipLevelSize;
 
         if (currentMipLevel < static_cast<int>(std::extent_v<decltype(IwiHeader::fileSizeForPicmip)>))
-            header.fileSizeForPicmip[currentMipLevel] = static_cast<uint32_t>(currentFileSize);
+            header.fileSizeForPicmip[currentMipLevel] = currentFileSize;
     }
 
-    if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
+    if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
     {
-        FillHeader3D(header, *texture3D);
+        FillHeader2D(header, *texture2D);
     }
     else if (const auto* textureCube = dynamic_cast<const TextureCube*>(texture))
     {
         FillHeaderCube(header, *textureCube);
     }
-    else if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
+    else if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
     {
-        FillHeader2D(header, *texture2D);
+        FillHeader3D(header, *texture3D);
     }
     else
     {

src/ObjImage/Image/IwiWriter8.cpp

@@ -105,20 +105,20 @@ void IwiWriter::DumpImage(std::ostream& stream, const Texture* texture)
         currentFileSize += mipLevelSize;
 
         if (currentMipLevel < static_cast<int>(std::extent_v<decltype(IwiHeader::fileSizeForPicmip)>))
-            header.fileSizeForPicmip[currentMipLevel] = static_cast<uint32_t>(currentFileSize);
+            header.fileSizeForPicmip[currentMipLevel] = currentFileSize;
     }
 
-    if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
+    if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
     {
-        FillHeader3D(header, *texture3D);
+        FillHeader2D(header, *texture2D);
     }
     else if (const auto* textureCube = dynamic_cast<const TextureCube*>(texture))
     {
         FillHeaderCube(header, *textureCube);
     }
-    else if (const auto* texture2D = dynamic_cast<const Texture2D*>(texture))
+    else if (const auto* texture3D = dynamic_cast<const Texture3D*>(texture))
     {
-        FillHeader2D(header, *texture2D);
+        FillHeader3D(header, *texture3D);
     }
     else
     {

src/ObjLoading.lua

@@ -55,7 +55,7 @@ function ObjLoading:project()
 		useSourceTemplating("ObjLoading")
 		
 		self:include(includes)
-		Cryptography:include(includes)
+		Crypto:include(includes)
 		Utils:include(includes)
 		minilzo:include(includes)
 		minizip:include(includes)

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();
 
-            auto dataSize = 0uz;
+            size_t dataSize = 0;
             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 = static_cast<unsigned>(dataSize);
+            loadDef->resourceSize = dataSize;
 
             char* currentDataBuffer = loadDef->data;
             for (auto mipLevel = 0; mipLevel < mipCount; mipLevel++)

src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp

@@ -21,7 +21,7 @@ namespace
 {
     void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetXAnim>>(memory));
@@ -85,7 +85,7 @@ namespace
 
     void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));

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) const
+                                   AssetRegistration<AssetMenuList>& registration)
         {
             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) const
+                                  AssetRegistration<AssetMenuList>& registration)
         {
             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 = 0uz;
+            auto totalItemCount = 0u;
             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) const
+        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus)
         {
             menuList.menuCount = static_cast<int>(menus.size());
 
@@ -196,8 +196,7 @@ namespace
                 menuList.menus = nullptr;
         }
 
-        std::unique_ptr<menu::ParsingResult>
+        std::unique_ptr<menu::ParsingResult> ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState)
-            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/Menu/MenuConversionZoneStateIW4.cpp

@@ -12,10 +12,10 @@ MenuConversionZoneState::MenuConversionZoneState()
 
 void MenuConversionZoneState::Inject(ZoneAssetCreationInjection& inject)
 {
-    auto& memory = inject.m_zone.Memory();
+    auto* memory = inject.m_zone.GetMemory();
 
     m_zone = &inject.m_zone;
-    m_supporting_data = memory.Alloc<ExpressionSupportingData>();
+    m_supporting_data = memory->Alloc<ExpressionSupportingData>();
 }
 
 Statement_s* MenuConversionZoneState::FindFunction(const std::string& functionName)
@@ -43,10 +43,10 @@ size_t MenuConversionZoneState::AddStaticDvar(const std::string& dvarName)
     if (foundDvar != m_dvars_by_name.end())
         return foundDvar->second;
 
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
-    auto* staticDvar = memory.Alloc<StaticDvar>();
+    auto* staticDvar = memory->Alloc<StaticDvar>();
 
-    staticDvar->dvarName = memory.Dup(dvarName.c_str());
+    staticDvar->dvarName = memory->Dup(dvarName.c_str());
     staticDvar->dvar = nullptr;
 
     const auto staticDvarIndex = m_static_dvars.size();
@@ -63,8 +63,8 @@ const char* MenuConversionZoneState::AddString(const std::string& str)
     if (foundString != m_strings_by_value.end())
         return foundString->second;
 
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
-    const auto* strDuped = memory.Dup(str.c_str());
+    const auto* strDuped = memory->Dup(str.c_str());
 
     m_strings.push_back(strDuped);
     m_strings_by_value.emplace(std::make_pair(str, strDuped));
@@ -79,24 +79,24 @@ void MenuConversionZoneState::AddLoadedFile(std::string loadedFileName, std::vec
 
 void MenuConversionZoneState::FinalizeSupportingData() const
 {
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
 
     m_supporting_data->uifunctions.totalFunctions = static_cast<int>(m_functions.size());
     m_supporting_data->staticDvarList.numStaticDvars = static_cast<int>(m_static_dvars.size());
     m_supporting_data->uiStrings.totalStrings = static_cast<int>(m_strings.size());
 
     if (m_supporting_data->uifunctions.functions)
-        memory.Free(m_supporting_data->uifunctions.functions);
+        memory->Free(m_supporting_data->uifunctions.functions);
 
     if (m_supporting_data->staticDvarList.staticDvars)
-        memory.Free(m_supporting_data->staticDvarList.staticDvars);
+        memory->Free(m_supporting_data->staticDvarList.staticDvars);
 
     if (m_supporting_data->uiStrings.strings)
-        memory.Free(m_supporting_data->uiStrings.strings);
+        memory->Free(m_supporting_data->uiStrings.strings);
 
     if (!m_functions.empty())
     {
-        m_supporting_data->uifunctions.functions = memory.Alloc<Statement_s*>(m_functions.size());
+        m_supporting_data->uifunctions.functions = memory->Alloc<Statement_s*>(m_functions.size());
         memcpy(m_supporting_data->uifunctions.functions, m_functions.data(), sizeof(void*) * m_functions.size());
     }
     else
@@ -104,7 +104,7 @@ void MenuConversionZoneState::FinalizeSupportingData() const
 
     if (!m_static_dvars.empty())
     {
-        m_supporting_data->staticDvarList.staticDvars = memory.Alloc<StaticDvar*>(m_static_dvars.size());
+        m_supporting_data->staticDvarList.staticDvars = memory->Alloc<StaticDvar*>(m_static_dvars.size());
         memcpy(m_supporting_data->staticDvarList.staticDvars, m_static_dvars.data(), sizeof(void*) * m_static_dvars.size());
     }
     else
@@ -112,7 +112,7 @@ void MenuConversionZoneState::FinalizeSupportingData() const
 
     if (!m_strings.empty())
     {
-        m_supporting_data->uiStrings.strings = memory.Alloc<const char*>(m_strings.size());
+        m_supporting_data->uiStrings.strings = memory->Alloc<const char*>(m_strings.size());
         memcpy(m_supporting_data->uiStrings.strings, m_strings.data(), sizeof(void*) * m_strings.size());
     }
     else

src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp

@@ -34,7 +34,7 @@ namespace
 {
     void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysCollMap>>(memory));
@@ -118,7 +118,7 @@ namespace
 
     void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddAssetCreator(std::make_unique<RawLoaderPhysPreset>(memory, searchPath, zone));
         collection.AddAssetCreator(std::make_unique<GdtLoaderPhysPreset>(memory, gdt, zone));

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 = static_cast<unsigned>(compressionBufferSize);
+            zs.avail_out = 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:
-        static StructuredDataType ConvertType(const CommonStructuredDataType inputType)
+        StructuredDataType ConvertType(CommonStructuredDataType inputType)
         {
             switch (inputType.m_category)
             {
             case CommonStructuredDataTypeCategory::INT:
-                return {.type = DATA_INT, .u = {}};
+                return {DATA_INT, {0}};
             case CommonStructuredDataTypeCategory::BYTE:
-                return {.type = DATA_BYTE, .u = {}};
+                return {DATA_BYTE, {0}};
             case CommonStructuredDataTypeCategory::BOOL:
-                return {.type = DATA_BOOL, .u = {}};
+                return {DATA_BOOL, {0}};
             case CommonStructuredDataTypeCategory::FLOAT:
-                return {.type = DATA_FLOAT, .u = {}};
+                return {DATA_FLOAT, {0}};
             case CommonStructuredDataTypeCategory::SHORT:
-                return {.type = DATA_SHORT, .u = {}};
+                return {DATA_SHORT, {0}};
             case CommonStructuredDataTypeCategory::STRING:
-                return {.type = DATA_STRING, .u = {static_cast<unsigned>(inputType.m_info.string_length)}};
+                return {DATA_STRING, {static_cast<unsigned>(inputType.m_info.string_length)}};
             case CommonStructuredDataTypeCategory::ENUM:
-                return {.type = DATA_ENUM, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {DATA_ENUM, {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::STRUCT:
-                return {.type = DATA_STRUCT, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {DATA_STRUCT, {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::INDEXED_ARRAY:
-                return {.type = DATA_INDEXED_ARRAY, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {DATA_INDEXED_ARRAY, {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::ENUM_ARRAY:
-                return {.type = DATA_ENUM_ARRAY, .u = {static_cast<unsigned>(inputType.m_info.type_index)}};
+                return {DATA_ENUM_ARRAY, {static_cast<unsigned>(inputType.m_info.type_index)}};
             case CommonStructuredDataTypeCategory::UNKNOWN:
             default:
                 assert(false);
-                return {.type = DATA_INT, .u = {0}};
+                return {DATA_INT, {0}};
             }
         }
 
-        void ConvertEnum(CommonStructuredDataEnum& inputEnum, StructuredDataEnum& outputEnum) const
+        void ConvertEnum(CommonStructuredDataEnum& inputEnum, StructuredDataEnum& outputEnum)
         {
             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) const
+        void ConvertStruct(CommonStructuredDataStruct& inputStruct, StructuredDataStruct& outputStruct)
         {
             outputStruct.size = static_cast<int>(inputStruct.m_size_in_byte);
-            outputStruct.bitOffset = static_cast<unsigned>(inputStruct.m_bit_offset);
+            outputStruct.bitOffset = 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 = static_cast<unsigned>(inputProperty.m_offset_in_bits / 8uz);
+                        outputProperty.offset = inputProperty.m_offset_in_bits / 8;
                     }
                     else
-                        outputProperty.offset = static_cast<unsigned>(inputProperty.m_offset_in_bits);
+                        outputProperty.offset = inputProperty.m_offset_in_bits;
                 }
             }
             else
                 outputStruct.properties = nullptr;
         }
 
-        static void ConvertIndexedArray(const CommonStructuredDataIndexedArray& inputIndexedArray, StructuredDataIndexedArray& outputIndexedArray)
+        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 = static_cast<unsigned>(utils::Align(inputIndexedArray.m_element_size_in_bits, 8uz) / 8uz);
+            outputIndexedArray.elementSize = 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 = static_cast<unsigned>(utils::Align(inputEnumedArray.m_element_size_in_bits, 8uz) / 8uz);
+            outputEnumedArray.elementSize = utils::Align(inputEnumedArray.m_element_size_in_bits, 8uz) / 8uz;
         }
 
         void ConvertDef(const CommonStructuredDataDef& inputDef, StructuredDataDef& outputDef)
         {
             outputDef.version = inputDef.m_version;
-            outputDef.formatChecksum = static_cast<unsigned>(inputDef.m_checksum);
+            outputDef.formatChecksum = 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 = static_cast<unsigned>(inputDef.m_size_in_byte);
+            outputDef.size = 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 = static_cast<unsigned>(commonDefs.size());
+            set->defCount = 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,7 +46,8 @@ namespace
     public:
         typedef const float (*literal_t)[4];
 
-        [[nodiscard]] const LoadedTechnique* FindLoadedTechnique(const std::string& techniqueName) const
+    public:
+        _NODISCARD const LoadedTechnique* FindLoadedTechnique(const std::string& techniqueName) const
         {
             const auto loadedTechnique = m_loaded_techniques.find(techniqueName);
             if (loadedTechnique != m_loaded_techniques.end())
@@ -85,6 +86,8 @@ 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)
         {
@@ -105,9 +108,9 @@ namespace
             }
 
             const auto shaderData = std::make_unique<char[]>(shaderSize);
-            file.m_stream->read(shaderData.get(), static_cast<std::streamsize>(shaderSize));
+            file.m_stream->read(shaderData.get(), shaderSize);
 
-            auto shaderInfo = d3d9::ShaderAnalyser::GetShaderInfo(shaderData.get(), shaderSize);
+            auto shaderInfo = d3d9::ShaderAnalyser::GetShaderInfo(reinterpret_cast<const uint32_t*>(shaderData.get()), shaderSize);
             if (!shaderInfo)
                 return nullptr;
 
@@ -115,9 +118,6 @@ 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,13 +126,10 @@ namespace
         class PassShaderArgument
         {
         public:
-            explicit PassShaderArgument(const MaterialShaderArgument arg)
+            MaterialShaderArgument m_arg;
-                : m_arg(arg),
+            MaterialUpdateFrequency m_update_frequency;
-                  m_update_frequency(GetUpdateFrequencyForArg(arg))
-            {
-            }
 
-            static MaterialUpdateFrequency GetUpdateFrequencyForArg(const MaterialShaderArgument arg)
+            static MaterialUpdateFrequency GetUpdateFrequencyForArg(MaterialShaderArgument arg)
             {
                 switch (arg.type)
                 {
@@ -163,22 +160,15 @@ namespace
                 }
             }
 
-            MaterialShaderArgument m_arg;
+            explicit PassShaderArgument(const MaterialShaderArgument arg)
-            MaterialUpdateFrequency m_update_frequency;
+                : m_arg(arg),
+                  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;
@@ -194,8 +184,21 @@ 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),
@@ -214,11 +217,10 @@ namespace
             m_passes.emplace_back();
         }
 
-        static unsigned RegisterCountPerElement(const d3d9::ShaderConstant& constant)
+        static size_t 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;
         }
 
@@ -241,7 +243,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;
@@ -256,7 +258,7 @@ namespace
                     return false;
 
                 argument.type = MTL_ARG_CODE_PIXEL_SAMPLER;
-                argument.u.codeSampler = samplerSource->source + static_cast<unsigned>(elementOffset);
+                argument.u.codeSampler = samplerSource->source + elementOffset;
 
                 arrayCount = static_cast<unsigned>(samplerSource->arrayCount);
             }
@@ -302,12 +304,13 @@ namespace
                     {
                         if (!AutoCreateShaderArgument(techset::ShaderSelector::VERTEX_SHADER, argument, elementIndex, registerIndex))
                         {
-                            std::string elementIndexStr;
+                            std::ostringstream ss;
-                            if (argument.m_type_elements > 1)
+                            ss << "Unassigned vertex shader \"" << pass.m_vertex_shader->m_name << "\" arg: " << argument.m_name;
-                                elementIndexStr = std::format("[{}]", elementIndex);
 
-                            errorMessage =
+                            if (argument.m_type_elements > 1)
-                                std::format("Unassigned vertex shader \"{}\" arg: {}{}", pass.m_vertex_shader->m_name, argument.m_name, elementIndexStr);
+                                ss << '[' << elementIndex << ']';
+
+                            errorMessage = ss.str();
                             return false;
                         }
                     }
@@ -569,11 +572,11 @@ namespace
             return foundSource;
         }
 
-        static bool FindShaderArgument(const d3d9::ShaderInfo& shaderInfo,
+        bool FindShaderArgument(const d3d9::ShaderInfo& shaderInfo,
                                 const techset::ShaderArgument& argument,
                                 size_t& constantIndex,
                                 size_t& registerOffset,
-                                       std::string& errorMessage)
+                                std::string& errorMessage) const
         {
             const auto matchingShaderConstant = std::ranges::find_if(shaderInfo.m_constants,
                                                                      [argument](const d3d9::ShaderConstant& constant)
@@ -851,14 +854,14 @@ namespace
         }
 
         bool AcceptShaderLiteralArgument(const techset::ShaderSelector shader,
-                                         const techset::ShaderArgument shaderArgument,
+                                         techset::ShaderArgument shaderArgument,
-                                         const techset::ShaderArgumentLiteralSource source,
+                                         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)
@@ -910,14 +913,14 @@ namespace
         }
 
         bool AcceptShaderMaterialArgument(const techset::ShaderSelector shader,
-                                          const techset::ShaderArgument shaderArgument,
+                                          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)
@@ -1013,8 +1016,6 @@ namespace
             return true;
         }
 
-        std::vector<Pass> m_passes;
-
     private:
         const std::string& m_technique_name;
         ISearchPath& m_search_path;

src/ObjLoading/Game/IW5/Material/JsonMaterialLoader.cpp

@@ -1,8 +1,8 @@
 #include "JsonMaterialLoader.h"
 
-#include "Base64.h"
 #include "Game/IW5/CommonIW5.h"
 #include "Game/IW5/Material/JsonMaterial.h"
+#include "Impl/Base64.h"
 
 #include <format>
 #include <iostream>

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) const
+                                   AssetRegistration<AssetMenuList>& registration)
         {
             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) const
+                                  AssetRegistration<AssetMenuList>& registration)
         {
             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 += static_cast<unsigned>(menu->m_items.size());
+                totalItemCount += 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)
             {
-                const auto converter = IMenuConverter::Create(ObjLoading::Configuration.MenuNoOptimization, m_search_path, m_memory, context);
+                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) const
+        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus)
         {
             menuList.menuCount = static_cast<int>(menus.size());
 
@@ -196,8 +196,7 @@ namespace
                 menuList.menus = nullptr;
         }
 
-        std::unique_ptr<menu::ParsingResult>
+        std::unique_ptr<menu::ParsingResult> ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState)
-            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/Menu/MenuConversionZoneStateIW5.cpp

@@ -12,10 +12,10 @@ MenuConversionZoneState::MenuConversionZoneState()
 
 void MenuConversionZoneState::Inject(ZoneAssetCreationInjection& inject)
 {
-    auto& memory = inject.m_zone.Memory();
+    auto* memory = inject.m_zone.GetMemory();
 
     m_zone = &inject.m_zone;
-    m_supporting_data = memory.Alloc<ExpressionSupportingData>();
+    m_supporting_data = memory->Alloc<ExpressionSupportingData>();
 }
 
 Statement_s* MenuConversionZoneState::FindFunction(const std::string& functionName)
@@ -43,10 +43,10 @@ size_t MenuConversionZoneState::AddStaticDvar(const std::string& dvarName)
     if (foundDvar != m_dvars_by_name.end())
         return foundDvar->second;
 
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
-    auto* staticDvar = memory.Alloc<StaticDvar>();
+    auto* staticDvar = memory->Alloc<StaticDvar>();
 
-    staticDvar->dvarName = memory.Dup(dvarName.c_str());
+    staticDvar->dvarName = memory->Dup(dvarName.c_str());
     staticDvar->dvar = nullptr;
 
     const auto staticDvarIndex = m_static_dvars.size();
@@ -63,8 +63,8 @@ const char* MenuConversionZoneState::AddString(const std::string& str)
     if (foundString != m_strings_by_value.end())
         return foundString->second;
 
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
-    const auto* strDuped = memory.Dup(str.c_str());
+    const auto* strDuped = memory->Dup(str.c_str());
 
     m_strings.push_back(strDuped);
     m_strings_by_value.emplace(std::make_pair(str, strDuped));
@@ -79,24 +79,24 @@ void MenuConversionZoneState::AddLoadedFile(std::string loadedFileName, std::vec
 
 void MenuConversionZoneState::FinalizeSupportingData() const
 {
-    auto& memory = m_zone->Memory();
+    auto* memory = m_zone->GetMemory();
 
     m_supporting_data->uifunctions.totalFunctions = static_cast<int>(m_functions.size());
     m_supporting_data->staticDvarList.numStaticDvars = static_cast<int>(m_static_dvars.size());
     m_supporting_data->uiStrings.totalStrings = static_cast<int>(m_strings.size());
 
     if (m_supporting_data->uifunctions.functions)
-        memory.Free(m_supporting_data->uifunctions.functions);
+        memory->Free(m_supporting_data->uifunctions.functions);
 
     if (m_supporting_data->staticDvarList.staticDvars)
-        memory.Free(m_supporting_data->staticDvarList.staticDvars);
+        memory->Free(m_supporting_data->staticDvarList.staticDvars);
 
     if (m_supporting_data->uiStrings.strings)
-        memory.Free(m_supporting_data->uiStrings.strings);
+        memory->Free(m_supporting_data->uiStrings.strings);
 
     if (!m_functions.empty())
     {
-        m_supporting_data->uifunctions.functions = memory.Alloc<Statement_s*>(m_functions.size());
+        m_supporting_data->uifunctions.functions = memory->Alloc<Statement_s*>(m_functions.size());
         memcpy(m_supporting_data->uifunctions.functions, m_functions.data(), sizeof(void*) * m_functions.size());
     }
     else
@@ -104,7 +104,7 @@ void MenuConversionZoneState::FinalizeSupportingData() const
 
     if (!m_static_dvars.empty())
     {
-        m_supporting_data->staticDvarList.staticDvars = memory.Alloc<StaticDvar*>(m_static_dvars.size());
+        m_supporting_data->staticDvarList.staticDvars = memory->Alloc<StaticDvar*>(m_static_dvars.size());
         memcpy(m_supporting_data->staticDvarList.staticDvars, m_static_dvars.data(), sizeof(void*) * m_static_dvars.size());
     }
     else
@@ -112,7 +112,7 @@ void MenuConversionZoneState::FinalizeSupportingData() const
 
     if (!m_strings.empty())
     {
-        m_supporting_data->uiStrings.strings = memory.Alloc<const char*>(m_strings.size());
+        m_supporting_data->uiStrings.strings = memory->Alloc<const char*>(m_strings.size());
         memcpy(m_supporting_data->uiStrings.strings, m_strings.data(), sizeof(void*) * m_strings.size());
     }
     else

src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp

@@ -29,7 +29,7 @@ namespace
 {
     void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysCollMap>>(memory));
@@ -119,7 +119,7 @@ namespace
 
     void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysCollMap>(memory));

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 = static_cast<unsigned>(compressionBufferSize);
+            zs.avail_out = 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 + static_cast<size_t>(scriptFile->compressedLen + scriptFile->bytecodeLen) > static_cast<size_t>(file.m_length))
+            if (offset + (scriptFile->compressedLen + scriptFile->bytecodeLen) > 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 = static_cast<unsigned>(valueArray.size());
+            m_weapon.weapCompleteDef.numAnimOverrides = valueArray.size();
 
             return true;
         }
@@ -267,7 +267,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.soundOverrides = soundOverrides;
-            m_weapon.weapCompleteDef.numSoundOverrides = static_cast<unsigned>(valueArray.size());
+            m_weapon.weapCompleteDef.numSoundOverrides = valueArray.size();
 
             return true;
         }
@@ -305,7 +305,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.fxOverrides = fxOverrides;
-            m_weapon.weapCompleteDef.numFxOverrides = static_cast<unsigned>(valueArray.size());
+            m_weapon.weapCompleteDef.numFxOverrides = valueArray.size();
 
             return true;
         }
@@ -339,7 +339,7 @@ namespace
             }
 
             m_weapon.weapCompleteDef.reloadOverrides = reloadOverrides;
-            m_weapon.weapCompleteDef.numReloadStateTimerOverrides = static_cast<unsigned>(valueArray.size());
+            m_weapon.weapCompleteDef.numReloadStateTimerOverrides = 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 = static_cast<unsigned>(overrideVector.size());
+            m_weapon.weapCompleteDef.numNotetrackOverrides = overrideVector.size();
 
             return true;
         }
@@ -437,7 +437,7 @@ namespace
             return false;
         }
 
-        void ParseAnim(const std::string& value, const char*& animName) const
+        void ParseAnim(const std::string& value, const char*& animName)
         {
             if (value == "none")
             {
@@ -449,7 +449,7 @@ namespace
             m_registration.AddIndirectAssetReference(m_context.LoadIndirectAssetReference<AssetXAnim>(value));
         }
 
-        void ParseSoundAlias(const std::string& value, SndAliasCustom& soundAlias) const
+        void ParseSoundAlias(const std::string& value, SndAliasCustom& soundAlias)
         {
             if (value == "none")
             {
@@ -462,7 +462,7 @@ namespace
             m_registration.AddIndirectAssetReference(m_context.LoadIndirectAssetReference<AssetSound>(value));
         }
 
-        bool ParseFxEffectDef(const std::string& value, FxEffectDef*& fx) const
+        bool ParseFxEffectDef(const std::string& value, FxEffectDef*& fx)
         {
             if (value == "none")
             {
@@ -542,7 +542,7 @@ namespace
             return true;
         }
 
-        void ParseScriptString(const std::string& value, ScriptString& out) const
+        void ParseScriptString(const std::string& value, ScriptString& out)
         {
             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) const
+AssetCreationResult InfoStringLoaderWeapon::CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context)
 {
     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) const;
+        AssetCreationResult CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context);
 
     private:
         MemoryManager& m_memory;

src/ObjLoading/Game/T5/ObjLoaderT5.cpp

@@ -21,7 +21,7 @@ namespace
 {
     void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
         collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysConstraints>>(memory));
@@ -97,7 +97,7 @@ namespace
 
     void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
     {
-        auto& memory = zone.Memory();
+        auto& memory = *zone.GetMemory();
 
         // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysConstraints>(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) const
+        AssetCreationResult LoadGsc(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
         {
             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 = static_cast<unsigned>(compressionBufferSize);
+            zs.avail_out = 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] = static_cast<uint32_t>(compressedSize);    // inLen
+            reinterpret_cast<uint32_t*>(compressedBuffer)[1] = 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) const
+        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
         {
             auto* rawFile = m_memory.Alloc<RawFile>();
             rawFile->name = m_memory.Dup(assetName.c_str());

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

@@ -5,7 +5,9 @@
 #include "Game/T6/T6.h"
 
 #include <algorithm>
+#include <cstring>
 #include <format>
+#include <sstream>
 
 using namespace T6;
 
@@ -23,8 +25,8 @@ namespace
     constexpr unsigned ROW_ALIAS_NAME = 2;
     constexpr unsigned ROW_ALIAS_BUTTON = 3;
 
-    constexpr auto VALUE_TYPE_ICON = "icon";
+    constexpr const char* VALUE_TYPE_ICON = "icon";
-    constexpr auto VALUE_TYPE_ALIAS = "alias";
+    constexpr const char* VALUE_TYPE_ALIAS = "alias";
 
     constexpr unsigned COL_COUNT_ICON = 7;
     constexpr unsigned COL_COUNT_ALIAS = 4;
@@ -123,8 +125,8 @@ namespace
                 }
             }
 
-            fontIcon->numEntries = static_cast<unsigned>(entries.size());
+            fontIcon->numEntries = entries.size();
-            fontIcon->numAliasEntries = static_cast<unsigned>(aliases.size());
+            fontIcon->numAliasEntries = aliases.size();
 
             if (fontIcon->numEntries > 0)
             {
@@ -157,7 +159,7 @@ namespace
         {
             for (auto& cell : row)
             {
-                for (const auto c : cell)
+                for (auto c : cell)
                 {
                     if (isspace(c))
                         continue;
@@ -218,7 +220,7 @@ namespace
                          const std::string& assetName,
                          const unsigned rowIndex,
                          AssetCreationContext& context,
-                         AssetRegistration<AssetFontIcon>& registration) const
+                         AssetRegistration<AssetFontIcon>& registration)
         {
             if (row.size() < COL_COUNT_ICON)
             {
@@ -244,7 +246,6 @@ 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());
@@ -253,7 +254,7 @@ namespace
             return true;
         }
 
-        static bool ReadAliasRow(
+        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(), static_cast<std::streamsize>(fileSize));
+            file.m_stream->read(fileData.get(), fileSize);
-            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(fileData.get()), static_cast<unsigned>(fileSize)));
+            const auto dataHash = static_cast<unsigned>(crc32(0u, reinterpret_cast<const Bytef*>(fileData.get()), fileSize));
 
             std::istringstream ss(std::string(fileData.get(), fileSize));
             const auto texture = iwi::LoadIwi(ss);

src/ObjLoading/Game/T6/ObjLoaderT6.cpp

@@ -284,7 +284,7 @@ namespace T6
     {
         void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
         {
-            auto& memory = zone.Memory();
+            auto& memory = *zone.GetMemory();
 
             collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
             collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysConstraints>>(memory));
@@ -390,7 +390,7 @@ namespace T6
 
         void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt)
         {
-            auto& memory = zone.Memory();
+            auto& memory = *zone.GetMemory();
 
             collection.AddAssetCreator(CreateRawPhysPresetLoader(memory, searchPath, zone));
             collection.AddAssetCreator(CreateGdtPhysPresetLoader(memory, searchPath, gdt, zone));

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 = static_cast<unsigned>(compressionBufferSize);
+            zs.avail_out = 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) const
+        AssetCreationResult LoadDefault(const SearchPathOpenFile& file, const std::string& assetName, AssetCreationContext& context)
         {
             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 = static_cast<unsigned>(aliasLists.size());
+        sndBank->aliasCount = 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 = static_cast<unsigned short>(i);
+                sndBank->aliasIndex[idx].value = i;
                 sndBank->aliasIndex[idx].next = std::numeric_limits<unsigned short>::max();
                 setAliasIndexList[i] = true;
             }
@@ -720,14 +720,14 @@ namespace
             }
 
             auto offset = 1u;
-            unsigned short freeIdx;
+            auto freeIdx = std::numeric_limits<unsigned short>::max();
             while (true)
             {
-                freeIdx = static_cast<unsigned short>((idx + offset) % sndBank->aliasCount);
+                freeIdx = (idx + offset) % sndBank->aliasCount;
                 if (sndBank->aliasIndex[freeIdx].value == std::numeric_limits<unsigned short>::max())
                     break;
 
-                freeIdx = static_cast<unsigned short>((idx + sndBank->aliasCount - offset) % sndBank->aliasCount);
+                freeIdx = (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 = static_cast<unsigned short>(i);
+            sndBank->aliasIndex[freeIdx].value = 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 = static_cast<unsigned>(radverbs.size());
+        sndBank->radverbCount = radverbs.size();
         if (sndBank->radverbCount)
         {
             sndBank->radverbs = memory.Alloc<SndRadverb>(sndBank->radverbCount);
@@ -912,7 +912,7 @@ namespace
 
             for (auto& valueJson : duckJson["values"])
             {
-                const auto index = GetValueIndex(valueJson["duckGroup"].get<std::string>(), SOUND_DUCK_GROUPS, std::extent_v<decltype(SOUND_DUCK_GROUPS)>);
+                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 = static_cast<unsigned>(ducks.size());
+        sndBank->duckCount = ducks.size();
         if (sndBank->duckCount)
         {
             sndBank->ducks = memory.Alloc<SndDuck>(sndBank->duckCount);
@@ -1046,7 +1046,7 @@ namespace
 
                 if (result)
                 {
-                    sndBank->loadedAssets.dataSize = static_cast<unsigned>(dataSize);
+                    sndBank->loadedAssets.dataSize = 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 = static_cast<int>(attachmentUniqueIndex);
+                            attachmentUnique.childLink = attachmentUniqueIndex;
                             lastSibling = weapon.attachmentUniques[attachmentUniqueIndex];
                         }
                         else
                         {
-                            lastSibling->siblingLink = static_cast<int>(attachmentUniqueIndex);
+                            lastSibling->siblingLink = attachmentUniqueIndex;
                             lastSibling = weapon.attachmentUniques[attachmentUniqueIndex];
                         }
                     }

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

@@ -151,7 +151,7 @@ namespace
         {
             if (!jWeaponCamoMaterialSet.materials.empty())
             {
-                weaponCamoMaterialSet.numMaterials = static_cast<unsigned>(jWeaponCamoMaterialSet.materials.size());
+                weaponCamoMaterialSet.numMaterials = 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 = static_cast<unsigned>(jWeaponCamo.camoSets.size());
+                weaponCamo.numCamoSets = 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 = static_cast<unsigned>(jWeaponCamo.camoMaterials.size());
+                weaponCamo.numCamoMaterials = 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
         {
-            const IPakIndexEntryKey wantedKey{
+            IPakIndexEntryKey wantedKey{};
-                {.dataHash = dataHash, .nameHash = nameHash}
+            wantedKey.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), static_cast<unsigned>(dataSize));
+    return crc32(0, static_cast<const Bytef*>(data), dataSize);
 }

src/ObjLoading/ObjContainer/IPak/IPakEntryReadStream.cpp

@@ -2,7 +2,6 @@
 
 #include "ObjContainer/IPak/IPakTypes.h"
 
-#include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <minilzo.h>
@@ -25,7 +24,7 @@ IPakEntryReadStream::IPakEntryReadStream(
       m_current_command_offset(0),
       m_pos(startOffset),
       m_base_pos(startOffset),
-      m_end_pos(startOffset + static_cast<int64_t>(entrySize)),
+      m_end_pos(startOffset + entrySize),
       m_buffer_start_pos(0),
       m_buffer_end_pos(0)
 {
@@ -54,7 +53,8 @@ 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);
-    chunkCount = std::min(chunkCount, IPAK_CHUNK_COUNT_PER_READ);
+    if (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) * static_cast<int64_t>(IPAK_CHUNK_SIZE);
+    const auto endPos = startPos + static_cast<int64_t>(chunkCount) * 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 (static_cast<int64_t>(blockHeader->countAndOffset.offset) != m_file_head)
+    if (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 += static_cast<int64_t>(outputSize);
+            m_file_head += 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 += static_cast<int64_t>(commandSize);
+        m_file_head += commandSize;
     }
-    m_pos += static_cast<int64_t>(commandSize);
+    m_pos += 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);
-    std::streamsize countRead = 0;
+    int64_t countRead = 0;
 
     while (countRead < count)
     {
@@ -337,11 +337,12 @@ std::streamsize IPakEntryReadStream::xsgetn(char* ptr, const std::streamsize cou
         }
 
         auto sizeToRead = count - countRead;
-        sizeToRead = std::min(sizeToRead, static_cast<std::streamsize>(m_current_command_length - m_current_command_offset));
+        if (sizeToRead > m_current_command_length - m_current_command_offset)
+            sizeToRead = m_current_command_length - m_current_command_offset;
 
         if (sizeToRead > 0)
         {
-            assert(count - countRead >= sizeToRead);
+            assert(static_cast<size_t>(count - countRead) >= static_cast<size_t>(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 > static_cast<off_type>(m_size))
+            if (off > m_size)
                 return pos_type(-1);
 
-            return seekpos(static_cast<off_type>(m_size) - off, mode);
+            return seekpos(m_size - off, mode);
         }
 
-        return seekpos(static_cast<pos_type>(m_offset) + off, mode);
+        return seekpos(m_offset + off, mode);
     }
 
     pos_type seekpos(const pos_type pos, std::ios_base::openmode mode) override
     {
-        if (pos < 0 || pos >= static_cast<pos_type>(m_size))
+        if (pos < 0 || pos >= 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(std::move(entry))
+      m_entry(entry)
 {
 }
 
 bool SoundBankEntryInputStream::IsOpen() const
 {
-    return m_stream != nullptr;
+    return m_stream.get() != nullptr;
 }
 
 bool SoundBank::ReadHeader()
@@ -130,50 +130,49 @@ bool SoundBank::ReadHeader()
     m_stream->read(reinterpret_cast<char*>(&m_header), sizeof(m_header));
     if (m_stream->gcount() != sizeof(m_header))
     {
-        std::cerr << "Unexpected eof when trying to load sndbank header.\n";
+        printf("Unexpected eof when trying to load sndbank header.\n");
         return false;
     }
 
     if (m_header.magic != MAGIC)
     {
-        std::cerr << std::format("Invalid sndbank magic 0x{:x}\n", m_header.magic);
+        std::cout << "Invalid sndbank magic 0x" << std::hex << m_header.magic << "\n";
         return false;
     }
 
     if (m_header.version != VERSION)
     {
-        std::cerr << std::format("Unsupported sndbank version {} (should be {})\n", m_header.version, VERSION);
+        std::cout << "Unsupported sndbank version " << m_header.version << " (should be " << VERSION << ")\n";
         return false;
     }
 
     if (m_header.entrySize != sizeof(SoundAssetBankEntry))
     {
-        std::cerr << std::format("Invalid sndbank entry size 0x{:x} (should be 0x{:x})\n", 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";
         return false;
     }
 
     if (m_header.fileSize != m_file_size)
     {
-        std::cerr << std::format("Invalid sndbank {} (header expects {})\n", m_file_size, m_header.fileSize);
+        std::cout << "Invalid sndbank " << m_file_size << " (header expects " << m_header.fileSize << ")\n";
         return false;
     }
 
-    if (m_header.entryCount
+    if (m_header.entryCount && (m_header.entryOffset <= 0 || m_header.entryOffset + sizeof(SoundAssetBankEntry) * m_header.entryCount > m_file_size))
-        && (m_header.entryOffset <= 0 || m_header.entryOffset + sizeof(SoundAssetBankEntry) * m_header.entryCount > static_cast<size_t>(m_file_size)))
     {
-        std::cerr << std::format("Invalid sndbank entry offset {} (filesize is {})\n", m_header.entryOffset, m_file_size);
+        std::cout << "Invalid sndbank entry offset " << m_header.entryOffset << " (filesize is " << m_file_size << ")\n";
         return false;
     }
 
-    if (m_header.checksumOffset <= 0 || m_header.checksumOffset + sizeof(SoundAssetBankChecksum) * m_header.entryCount > static_cast<size_t>(m_file_size))
+    if (m_header.checksumOffset <= 0 || m_header.checksumOffset + sizeof(SoundAssetBankChecksum) * m_header.entryCount > m_file_size)
     {
-        std::cerr << std::format("Invalid sndbank checksum offset {} (filesize is {})\n", m_header.checksumOffset, m_file_size);
+        std::cout << "Invalid sndbank checksum offset " << m_header.checksumOffset << " (filesize is " << m_file_size << ")\n";
         return false;
     }
 
     if (m_header.dependencyCount * m_header.dependencySize > sizeof(SoundAssetBankHeader::dependencies))
     {
-        std::cerr << std::format("Invalid sndbank dependency sizes (count is {}; size is {})\n", m_header.dependencyCount, m_header.dependencySize);
+        std::cout << "Invalid sndbank dependency sizes (count is " << m_header.dependencyCount << "; size is " << m_header.dependencySize << ")\n";
         return false;
     }
 
@@ -202,13 +201,13 @@ bool SoundBank::ReadEntries()
 
         if (m_stream->gcount() != sizeof(entry))
         {
-            std::cerr << std::format("Failed to read sound bank entry at index {}\n", i);
+            std::cout << "Failed to read sound bank entry at index " << i << "\n";
             return false;
         }
 
         if (entry.offset == 0 || entry.offset + entry.size >= m_file_size)
         {
-            std::cerr << std::format("Invalid sound bank entry data offset {} (filesize is {})\n", entry.offset, m_header.fileSize);
+            std::cout << "Invalid sound bank entry data offset " << entry.offset << " (filesize is " << m_header.fileSize << ")\n";
             return false;
         }
 
@@ -230,7 +229,7 @@ bool SoundBank::ReadChecksums()
 
         if (m_stream->gcount() != sizeof(checksum))
         {
-            std::cerr << std::format("Failed to read sound bank checksum at index {}\n", i);
+            std::cout << "Failed to read sound bank checksum at index " << i << "\n";
             return false;
         }
 

src/ObjLoading/ObjContainer/SoundBank/SoundBankWriter.cpp

@@ -1,6 +1,6 @@
 #include "SoundBankWriter.h"
 
-#include "Cryptography.h"
+#include "Crypto.h"
 #include "ObjContainer/SoundBank/SoundBankTypes.h"
 #include "Sound/FlacDecoder.h"
 #include "Sound/WavTypes.h"
@@ -251,7 +251,7 @@ public:
 
             SoundAssetBankChecksum checksum{};
 
-            const auto md5Crypt = cryptography::CreateMd5();
+            const auto md5Crypt = Crypto::CreateMD5();
             md5Crypt->Process(soundData.get(), soundSize);
             md5Crypt->Finish(checksum.checksumBytes);
 

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, static_cast<unsigned>(toRead));
+                    unzReadCurrentFile(m_container, temp, toRead);
                     skipAmount -= toRead;
                 }