release 1.8.0.2

* change tpfconvert functionality to backup into backup folder

* use vcpkg for more packages

* update readme, bump to 1.7.0.2

* rework dll path

* https://github.com/gwdevhub/gMod/issues/33

* v1.7.0.3

* debug mode enabled

* fix... something... somehow??? @STL can you explain this???

* safety

* 1.8.0.0

.github/workflows/cd.yaml

@@ -29,8 +29,20 @@ jobs:
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.3.1
 
-    - name: Build CMake Files
-      run: cmake -S . -B build -A Win32
+    - name: Install vcpkg
+      run: |
+        git clone https://github.com/microsoft/vcpkg.git
+        .\vcpkg\bootstrap-vcpkg.bat
+        
+    - name: Set VCPKG_ROOT
+      run: |
+        echo "VCPKG_ROOT=$(Get-Location)\vcpkg" >> $env:GITHUB_ENV
+      shell: powershell
+
+    - name: Build CMake Files with vcpkg toolchain
+      run: cmake --preset=vcpkg
+      env:
+        VCPKG_ROOT: ${{ env.VCPKG_ROOT }}
 
     - name: Build binaries
       run: cmake --build build --config Release
@@ -54,7 +66,7 @@ jobs:
         mode: update
         tag_name: v${{ steps.set_version.outputs.version }}
         release_name: gMod v${{ steps.set_version.outputs.version }}
-        assets: .\bin\Release\gMod.dll
+        assets: .\bin\Release\gMod.dll;.\bin\Release\TpfConvert.exe;.\bin\Release\d3dx9_43.dll
         github_token: ${{ env.GITHUB_TOKEN }}
         replace_assets: true
         body_mrkdwn: ${{ env.Changelog }}

.github/workflows/ci.yaml

@@ -1,4 +1,4 @@
-name:  gMod CI Pipeline
+name: gMod CI Pipeline
 
 on:
   pull_request:
@@ -8,9 +8,8 @@ on:
     branches:
       - dev
   workflow_dispatch:
-      
-jobs:
 
+jobs:
   build:
 
     strategy:
@@ -32,8 +31,20 @@ jobs:
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.3.1
 
-    - name: Build CMake Files
-      run: cmake -S . -B build -A Win32
+    - name: Install vcpkg
+      run: |
+        git clone https://github.com/microsoft/vcpkg.git
+        .\vcpkg\bootstrap-vcpkg.bat
+        
+    - name: Set VCPKG_ROOT
+      run: |
+        echo "VCPKG_ROOT=$(Get-Location)\vcpkg" >> $env:GITHUB_ENV
+      shell: powershell
+
+    - name: Build CMake Files with vcpkg toolchain
+      run: cmake --preset=vcpkg
+      env:
+        VCPKG_ROOT: ${{ env.VCPKG_ROOT }}
 
     - name: Build binaries
       run: cmake --build build --config Release

.gitignore

@@ -23,6 +23,8 @@ bin/
 */Release
 */bin
 */obj
+vcpkg
+vcpkg_installed
 
 # Bloated Windows Databases
 *.sdf

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.29)
 
 set(CMAKE_GENERATOR_PLATFORM win32)
 
@@ -9,16 +9,10 @@ if(NOT(CMAKE_SIZEOF_VOID_P EQUAL 4))
     message(FATAL_ERROR "You are configuring a non 32-bit build, this is not supported. Run cmake with `-A Win32`")
 endif()
 
-option(CLEAN "Cleans third party libraries and recompiles them" OFF)
-if(${CLEAN} MATCHES "ON")
-    message("Removing directory: ${PROJECT_SOURCE_DIR}/bin/install")
-    file(REMOVE_RECURSE ${PROJECT_SOURCE_DIR}/bin/install)
-endif()
-
 set(VERSION_MAJOR 1)
-set(VERSION_MINOR 6)
-set(VERSION_PATCH 2)
-set(VERSION_TWEAK 0)
+set(VERSION_MINOR 8)
+set(VERSION_PATCH 0)
+set(VERSION_TWEAK 2)
 
 set(VERSION_RC "${CMAKE_CURRENT_BINARY_DIR}/version.rc")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/version.rc.in" "${VERSION_RC}" @ONLY)
@@ -27,15 +21,14 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/bin")
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-set(CMAKE_INSTALL_PREFIX ${PROJECT_SOURCE_DIR}/bin/install)
 
 add_compile_options(/MP /permissive-)
 
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
-include(libzippp)
-include(minhook)
+find_package(libzippp CONFIG REQUIRED)
+find_package(minhook CONFIG REQUIRED)
+find_package(Microsoft.GSL CONFIG REQUIRED)
 include(dxtk)
-include(msgsl)
 
 add_library(gMod SHARED)
 
@@ -52,12 +45,13 @@ target_include_directories(gMod PRIVATE
     )
 source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${SOURCES})
 target_sources(gMod PRIVATE ${SOURCES})
+target_compile_options(gMod PRIVATE /W4 /WX)
 
 target_link_libraries(gMod PRIVATE
     dxguid
-    libzippp
+    libzippp::libzippp
     psapi
-    minhook
+    minhook::minhook
     directxtex
     Microsoft.GSL::GSL
     )
@@ -75,3 +69,5 @@ target_compile_definitions(gMod PRIVATE
     DIRECT_INJECTION
     LOG_MESSAGE
     )
+	
+add_subdirectory(TpfConvert)

CMakePresets.json

@@ -0,0 +1,16 @@
+{
+  "version": 2,
+  "configurePresets": [
+    {
+      "name": "vcpkg",
+      "generator": "Visual Studio 17 2022",
+	  "architecture": "Win32",
+      "binaryDir": "${sourceDir}/build",
+      "cacheVariables": {
+		"VCPKG_OVERLAY_TRIPLETS": "${sourceDir}/triplets",
+		"VCPKG_TARGET_TRIPLET": "x86-windows-mixed",
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+      }
+    }
+  ]
+}

README.md

@@ -1,11 +1,6 @@
-Requirements:
-- Visual Studio 2022
-- CMake 3.16+, integrated into the Developer Powershell for VS 2022
+***gMod***
 
-Compile:
-- cmake -B build
-- cmake --open build
-- compile
+Continuation of the uMod project to improve performance and stability. Integrated with [Guild Wars Launcher](https://github.com/gwdevhub/gwlauncher) and [Daybreak](https://github.com/gwdevhub/Daybreak).
 
 *Usage is primarily intended with GW Launcher or Daybreak, but it can be used without.*
 
@@ -21,6 +16,29 @@ Compile:
 
 **Format of the modlist.txt file:**
 
-
 Each line in the modlist.txt is the full path to a mod you want to load (eg. `D:\uMod\Borderless Cartography Made Easy 2015 1.3.tpf`)
 gMod will load all these files on startup
+
+**Disclaimer about [Reshade](https://github.com/crosire/reshade)**
+
+Reshade in versions > 5.0.1 is known to cause glitches with TexMod, uMod and also gMod.
+If you would like to use Reshade in combination with gMod, we recommend running version [5.0.1](https://github.com/crosire/reshade/releases/tag/v5.0.1) or [4.9.1](https://github.com/crosire/reshade/releases/tag/v4.9.1).
+
+**Build from source**
+
+Requirements:
+- Visual Studio 2022
+- CMake 3.29+, integrated into the Developer Powershell for VS 2022
+- vcpkg, integrated into the Developer Powershell for VS 2022
+
+Compile:
+- cmake --preset=vcpkg
+- cmake --open build
+- compile
+
+**TpfConvert**
+Small utility to convert old .tpf files with invalid images into .zip files with working images.
+Usage:
+- Put TpfConvert.exe and d3dx9.dll in the folder where you have your old, broken texmods with invalid images.
+- Run TpfConvert.exe, all *.tpf and *.zip files are processed. The originals are saved into a newly created backup folder.
+- Done.

TpfConvert/CMakeLists.txt

@@ -0,0 +1,39 @@
+add_executable(TpfConvert)
+
+# Find all .ixx files in the TpfConvert folder
+file(GLOB TPF_SOURCES "src/*.ixx")
+
+# Add the .ixx files to the TpfConvert target
+target_sources(TpfConvert PRIVATE ${TPF_SOURCES})
+
+set_target_properties(TpfConvert PROPERTIES
+    CXX_STANDARD 23
+    CXX_STANDARD_REQUIRED ON
+)
+
+target_compile_definitions(TpfConvert PRIVATE
+    "NOMINMAX"
+    "_WIN32_WINNT=_WIN32_WINNT_WIN7"
+    "WIN32_LEAN_AND_MEAN"
+    "VC_EXTRALEAN"
+)
+
+if(DEFINED ENV{VCPKG_ROOT})
+    message(STATUS "VCPKG_ROOT: $ENV{VCPKG_ROOT}")
+else()
+    message(STATUS "VCPKG_ROOT is not set")
+endif()
+
+if(DEFINED CMAKE_TOOLCHAIN_FILE)
+    message(STATUS "CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}")
+else()
+    message(STATUS "CMAKE_TOOLCHAIN_FILE is not set")
+endif()
+
+find_package(dxsdk-d3dx CONFIG REQUIRED)
+
+target_link_libraries(TpfConvert PRIVATE
+    libzippp::libzippp
+    Microsoft::D3DX9
+    d3d9
+)

TpfConvert/src/ModfileLoader.ixx

@@ -0,0 +1,180 @@
+export module ModfileLoader;
+
+import std;
+import <libzippp.h>;
+import ModfileLoader.TpfReader;
+
+export using HashType = uint64_t;
+
+export struct TexEntry {
+    std::vector<uint8_t> data{};
+    HashType crc_hash = 0; // hash value
+    std::string ext{};
+};
+
+namespace {
+    HashType GetCrcFromFilename(const std::string& filename) {
+        const static std::regex re(R"(0[xX][0-9a-fA-F]{4,16})", std::regex::optimize);
+        std::smatch match;
+        if (!std::regex_search(filename, match, re)) {
+            return 0;
+        }
+
+        uint64_t crc64_hash = 0;
+        const auto number_str = match.str();
+        try {
+            crc64_hash = std::stoull(number_str, nullptr, 16);
+        }
+        catch (const std::invalid_argument&) {
+            std::print(stderr, "Failed to parse {} as a hash\n", filename);
+            return 0;
+        }
+        catch (const std::out_of_range&) {
+            std::print(stderr, "Out of range while parsing {} as a hash\n", filename);
+            return 0;
+        }
+        return crc64_hash;
+    }
+}
+
+export class ModfileLoader {
+    std::filesystem::path file_name;
+    const std::string TPF_PASSWORD{
+        0x73, 0x2A, 0x63, 0x7D, 0x5F, 0x0A, static_cast<char>(0xA6), static_cast<char>(0xBD),
+        0x7D, 0x65, 0x7E, 0x67, 0x61, 0x2A, 0x7F, 0x7F,
+        0x74, 0x61, 0x67, 0x5B, 0x60, 0x70, 0x45, 0x74,
+        0x5C, 0x22, 0x74, 0x5D, 0x6E, 0x6A, 0x73, 0x41,
+        0x77, 0x6E, 0x46, 0x47, 0x77, 0x49, 0x0C, 0x4B,
+        0x46, 0x6F
+    };
+
+public:
+    ModfileLoader(const std::filesystem::path& fileName);
+
+    std::vector<TexEntry> GetContents() const;
+
+private:
+
+    std::vector<TexEntry> GetTpfContents() const;
+
+    std::vector<TexEntry> GetFileContents() const;
+
+    static void LoadEntries(libzippp::ZipArchive& archive, std::vector<TexEntry>& entries);
+};
+
+ModfileLoader::ModfileLoader(const std::filesystem::path& fileName)
+{
+    file_name = std::filesystem::absolute(fileName);
+}
+
+std::vector<TexEntry> ModfileLoader::GetContents() const
+{
+    try {
+        return file_name.wstring().ends_with(L".tpf") ? GetTpfContents() : GetFileContents();
+    }
+    catch (const std::exception&) {
+        std::print(stderr, "Failed to open mod file: {}\n", file_name.string().c_str());
+    }
+    return {};
+}
+
+std::vector<TexEntry> ModfileLoader::GetTpfContents() const
+{
+    std::vector<TexEntry> entries;
+    auto tpf_reader = TpfReader(file_name);
+    const auto buffer = tpf_reader.ReadToEnd();
+    const auto zip_archive = libzippp::ZipArchive::fromBuffer(buffer.data(), buffer.size(), false, TPF_PASSWORD);
+    if (!zip_archive) {
+    std::print(stderr, "Failed to open tpf file: {} - {} uint8_ts!\n", file_name.string(), buffer.size());
+        return {};
+    }
+    zip_archive->setErrorHandlerCallback(
+        [](const std::string& message, const std::string& strerror, int zip_error_code, int system_error_code) -> void {
+            std::print(stderr, "GetTpfContents: {} {} {} {}\n", message, strerror, zip_error_code, system_error_code);
+        });
+    zip_archive->open();
+    LoadEntries(*zip_archive, entries);
+    zip_archive->close();
+    libzippp::ZipArchive::free(zip_archive);
+
+    return entries;
+}
+
+std::vector<TexEntry> ModfileLoader::GetFileContents() const
+{
+    std::vector<TexEntry> entries;
+
+    libzippp::ZipArchive zip_archive(file_name.string());
+    zip_archive.open();
+    LoadEntries(zip_archive, entries);
+    zip_archive.close();
+
+    return entries;
+}
+
+void ParseSimpleArchive(const libzippp::ZipArchive& archive, std::vector<TexEntry>& entries)
+{
+    for (const auto& entry : archive.getEntries()) {
+        if (!entry.isFile())
+            continue;
+        const auto entry_name = entry.getName();
+        const auto crc_hash = GetCrcFromFilename(entry_name);
+        if (!crc_hash)
+            continue;
+        const auto data_ptr = static_cast<uint8_t*>(entry.readAsBinary());
+        const auto size = entry.getSize();
+        std::vector vec(data_ptr, data_ptr + size);
+        std::filesystem::path tex_name(entry_name);
+        entries.emplace_back(std::move(vec), crc_hash, tex_name.extension().string());
+        delete[] data_ptr;
+    }
+}
+
+void ParseTexmodArchive(std::vector<std::string>& lines, libzippp::ZipArchive& archive, std::vector<TexEntry>& entries)
+{
+    for (const auto& line : lines) {
+        // 0xC57D73F7|GW.EXE_0xC57D73F7.tga\r\n
+        // match[1] | match[2]
+        const static auto address_file_regex = std::regex(R"(^[\\/.]*([^|]+)\|([^\r\n]+))", std::regex::optimize);
+        std::smatch match;
+        if (!std::regex_search(line, match, address_file_regex))
+            continue;
+        const auto address_string = match[1].str();
+        const auto file_path = match[2].str();
+
+        const auto crc_hash = GetCrcFromFilename(address_string);
+        if (!crc_hash)
+            continue;
+
+        const auto entry = archive.getEntry(file_path);
+        if (entry.isNull() || !entry.isFile())
+            continue;
+
+        const auto data_ptr = static_cast<uint8_t*>(entry.readAsBinary());
+        const auto size = static_cast<size_t>(entry.getSize());
+        std::vector vec(data_ptr, data_ptr + size);
+        const auto tex_name = std::filesystem::path(entry.getName());
+        entries.emplace_back(std::move(vec), crc_hash, tex_name.extension().string());
+        delete[] data_ptr;
+    }
+}
+
+void ModfileLoader::LoadEntries(libzippp::ZipArchive& archive, std::vector<TexEntry>& entries)
+{
+    const auto def_file = archive.getEntry("texmod.def");
+    if (def_file.isNull() || !def_file.isFile()) {
+        ParseSimpleArchive(archive, entries);
+    }
+    else {
+        const auto def = def_file.readAsText();
+        std::istringstream iss(def);
+        std::vector<std::string> lines;
+        std::string line;
+
+        while (std::getline(iss, line)) {
+            lines.push_back(line);
+        }
+
+        ParseTexmodArchive(lines, archive, entries);
+    }
+}

TpfConvert/src/ModfileLoader_TpfReader.ixx

@@ -0,0 +1,58 @@
+export module ModfileLoader.TpfReader;
+
+import std;
+
+export class TpfReader {
+public:
+    TpfReader(const std::filesystem::path& path)
+    {
+        file_stream = std::ifstream(path, std::ios::binary);
+        if (!file_stream.seekg(0, std::ios::end).good() || !file_stream.seekg(0, std::ios::beg).good()) {
+            throw std::invalid_argument("Provided stream needs to have SEEK set to True");
+        }
+    }
+
+    ~TpfReader()
+    {
+        file_stream.close();
+    }
+
+    std::vector<char> ReadToEnd()
+    {
+        file_stream.seekg(0, std::ios::end);
+        line_length = file_stream.tellg();
+        file_stream.seekg(0, std::ios::beg); // Go to the beginning of the stream
+
+        std::vector<char> data(line_length);
+        file_stream.read(data.data(), line_length);
+        for (auto i = 0; i < data.size(); i++) {
+            data[i] = XOR(data[i], i);
+        }
+
+        for (int i = data.size() - 1; i > 0 && data[i] != 0; i--) {
+            data[i] = 0;
+        }
+
+        // in the other zip libraries, these had to be cut off, with libzip we need to zero them out
+        // cutting them off makes the archive invalid
+        //data.resize(last_zero);
+
+        return data;
+    }
+
+private:
+    std::ifstream file_stream;
+    long line_length = 0;
+
+    [[nodiscard]] char XOR(const char b, const long position) const
+    {
+        if (position >= (line_length / 4) * 4) {
+            return b ^ TPF_XOREven;
+        }
+
+        return position % 2 == 0 ? b ^ TPF_XOREven : b ^ TPF_XOROdd;
+    }
+
+    static constexpr char TPF_XOROdd = 0x3F;
+    static constexpr char TPF_XOREven = static_cast<char>(0xA4);
+};

TpfConvert/src/TpfConvert.ixx

@@ -0,0 +1,152 @@
+#include <corecrt_wstdio.h>
+#include <Windows.h>
+#include <d3dx9.h>
+#include <d3d9.h>
+
+import std;
+import ModfileLoader;
+import <libzippp.h>;
+
+struct TexEntry;
+
+namespace {
+    IDirect3D9* pD3D = nullptr;
+    IDirect3DDevice9* pDevice = nullptr;
+
+    bool InitializeDirect3D()
+    {
+        pD3D = Direct3DCreate9(D3D_SDK_VERSION);
+        if (pD3D == nullptr) {
+            std::print(stderr, "Failed to create Direct3D9 object\n");
+            return false;
+        }
+
+        D3DPRESENT_PARAMETERS d3dpp = {};
+        d3dpp.Windowed = TRUE;
+        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+        d3dpp.hDeviceWindow = GetDesktopWindow();
+
+        if (FAILED(pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, GetDesktopWindow(),
+            D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice))) {
+            std::print(stderr, "Failed to create Direct3D9 device\n");
+            pD3D->Release();
+            return false;
+        }
+
+        return true;
+    }
+
+    void CleanupDirect3D()
+    {
+        if (pDevice) pDevice->Release();
+        if (pD3D) pD3D->Release();
+    }
+
+    std::pair<std::string, std::vector<uint8_t>> SaveAsDDS(const TexEntry& entry)
+    {
+        IDirect3DTexture9* pTexture = nullptr;
+        ID3DXBuffer* pBuffer = nullptr;
+
+        HRESULT hr = D3DXCreateTextureFromFileInMemoryEx(pDevice,
+                                                         entry.data.data(), entry.data.size(),
+                                                         D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0,
+                                                         D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_NONE,
+                                                         D3DX_FILTER_NONE, 0, NULL, NULL, &pTexture);
+
+        if (FAILED(hr)) {
+            std::print(stderr, "Failed to create texture from memory\n");
+            return {};
+        }
+
+        hr = D3DXSaveTextureToFileInMemory(&pBuffer, D3DXIFF_DDS, pTexture, NULL);
+        if (FAILED(hr)) {
+            std::print(stderr, "Failed to save texture to DDS memory buffer\n");
+            pTexture->Release();
+            return {};
+        }
+
+        std::string dds_filename = std::format("0x{:x}.dds", entry.crc_hash);
+        std::vector<uint8_t> dds_data(pBuffer->GetBufferSize());
+        std::memcpy(dds_data.data(), pBuffer->GetBufferPointer(), pBuffer->GetBufferSize());
+
+        pTexture->Release();
+        pBuffer->Release();
+
+        return {dds_filename, dds_data};
+    }
+
+    std::filesystem::path GetExecutablePath()
+    {
+        char buffer[MAX_PATH];
+        GetModuleFileNameA(NULL, buffer, MAX_PATH);
+        return std::filesystem::path(buffer).parent_path();
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    const std::filesystem::path path = argc > 1 ? argv[1] : GetExecutablePath();
+    const auto backup_path = path / "backup";
+
+    if (!InitializeDirect3D()) {
+        return -1;
+    }
+
+    if (!std::filesystem::exists(path)) {
+        return 1;
+    }
+
+    if (!std::filesystem::exists(backup_path)) {
+        std::filesystem::create_directory(backup_path);
+    }
+
+    for (const auto& modfile : std::filesystem::directory_iterator(path)) {
+        if (modfile.is_regular_file() && (modfile.path().extension() == ".tpf" || modfile.path().extension() == ".zip")) {
+            const auto mod_path = modfile.path();
+            const auto backup_file = backup_path / mod_path.filename();
+
+            if (std::filesystem::exists( backup_file)) {
+                std::print("Skipping previous TpfConvert output: {}\n", mod_path.filename().string());
+                continue;
+            }
+            else {
+                std::print("Processing: {}\n", mod_path.filename().string());
+                std::error_code ec;
+                std::filesystem::rename(mod_path, backup_file, ec);
+            }
+
+            const auto zip_filename = path / (mod_path.stem().string() + ".zip");
+            if (std::filesystem::exists(zip_filename)) {
+                std::filesystem::remove(zip_filename);
+            }
+
+            ModfileLoader loader(backup_file);
+            std::vector<std::pair<std::string, std::vector<uint8_t>>> data_entries;
+            const auto entries = loader.GetContents();
+
+            libzippp::ZipArchive zip_archive(zip_filename.string());
+            zip_archive.open(libzippp::ZipArchive::Write);
+
+            for (const auto& entry : entries) {
+                auto [dds_filename, dds_data] = SaveAsDDS(entry);
+                if (!dds_filename.empty()) {
+                    data_entries.emplace_back(dds_filename, std::move(dds_data));
+                }
+            }
+
+            for (const auto& [filename, data] : data_entries) {
+                const auto success = zip_archive.addData(filename, data.data(), data.size());
+                if (!success) {
+                    std::print(stderr, "Failed to add data to ZIP: {}\n", filename);
+                }
+            }
+
+            zip_archive.close();
+            std::print("Saved to ZIP: {}\n", zip_filename.string());
+        }
+    }
+
+    CleanupDirect3D();
+
+    return 0;
+}

cmake/libzip.cmake

@@ -1,65 +0,0 @@
-include_guard()
-include(FetchContent)
-include(zlib)
-
-FetchContent_Declare(
-    libzip
-    GIT_REPOSITORY https://github.com/nih-at/libzip
-    GIT_TAG v1.10.1)
-FetchContent_GetProperties(libzip)
-
-if (libzip_POPULATED)
-    message(STATUS "Skipping libzip download")
-    return()
-endif()
-
-FetchContent_Populate(libzip)
-if(EXISTS ${CMAKE_INSTALL_PREFIX}/lib/zip.lib)
-    message(STATUS "Skipping libzip build")
-    return()
-endif()
-
-set(OPTIONS
-    "-A" "Win32"
-    "-DZLIB_LIBRARY:PATH=${CMAKE_INSTALL_PREFIX}/lib/zlibstatic.lib"
-    "-DZLIB_INCLUDE_DIR:PATH=${CMAKE_INSTALL_PREFIX}/include"
-    "-DENABLE_COMMONCRYPTO=OFF"
-    "-DENABLE_GNUTLS=OFF"
-    "-DENABLE_MBEDTLS=OFF"
-    "-DENABLE_OPENSSL=OFF"
-    "-DENABLE_WINDOWS_CRYPTO=ON"
-    "-DENABLE_FDOPEN=OFF"
-    "-DENABLE_BZIP2=OFF"
-    "-DENABLE_LZMA=OFF"
-    "-DENABLE_ZSTD=OFF"
-    "-DBUILD_TOOLS=OFF"
-    "-DBUILD_REGRESS=OFF"
-    "-DBUILD_EXAMPLES=OFF"
-    "-DBUILD_DOC=OFF"
-    "-DLIBZIP_DO_INSTALL=ON"
-    "-DBUILD_SHARED_LIBS=OFF"
-    "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
-    "-DCMAKE_MSVC_RUNTIME_LIBRARY=${CMAKE_MSVC_RUNTIME_LIBRARY}"
-    )
-
-message("Building libzip with OPTIONS:\n${OPTIONS}")
-
-# Patch CMakeLists.txt to require version 3.15 - otherwise cmake ignores MSVC_RUNTIME_LIBRARY
-file(READ ${libzip_SOURCE_DIR}/CMakeLists.txt FILE_CONTENT)
-string(REPLACE "VERSION 3.5.0" "VERSION 3.15.0" UPDATED_CONTENT "${FILE_CONTENT}")
-file(WRITE ${libzip_SOURCE_DIR}/CMakeLists.txt "${UPDATED_CONTENT}")
-      
-execute_process(
-    COMMAND ${CMAKE_COMMAND} ${OPTIONS} .
-    WORKING_DIRECTORY ${libzip_SOURCE_DIR}
-)
-execute_process(
-    COMMAND ${CMAKE_COMMAND} --build . --config Release
-    WORKING_DIRECTORY ${libzip_SOURCE_DIR}
-)
-execute_process(
-    COMMAND ${CMAKE_COMMAND} --install . --config Release
-    WORKING_DIRECTORY ${libzip_SOURCE_DIR}
-)
-
-message(STATUS "Finished libzip build")

cmake/libzippp.cmake

@@ -1,42 +0,0 @@
-include_guard()
-include(FetchContent)
-include(libzip)
-
-find_library(ZLIB_LIBRARY REQUIRED
-    NAMES zlibstatic
-    PATHS ${CMAKE_INSTALL_PREFIX}/lib
-)
-find_library(LIBZIP_LIBRARY REQUIRED
-    NAMES zip
-    PATHS ${CMAKE_INSTALL_PREFIX}/lib
-)
-
-FetchContent_Declare(
-    libzippp
-    GIT_REPOSITORY https://github.com/ctabin/libzippp
-    GIT_TAG libzippp-v7.0-1.10.1)
-FetchContent_GetProperties(libzippp)
-
-if (NOT libzippp_POPULATED)
-    FetchContent_Populate(libzippp)
-endif()
-
-add_library(libzippp STATIC)
-
-set(SOURCES
-    "${libzippp_SOURCE_DIR}/src/libzippp.h"
-    "${libzippp_SOURCE_DIR}/src/libzippp.cpp"
-    )
-source_group(TREE ${libzippp_SOURCE_DIR} FILES ${SOURCES})
-target_sources(libzippp PRIVATE ${SOURCES})
-target_include_directories(libzippp PUBLIC "${libzippp_SOURCE_DIR}/src")
-target_include_directories(libzippp PRIVATE "${CMAKE_INSTALL_PREFIX}/include")
-target_compile_definitions(libzippp PUBLIC
-    LIBZIPPP_WITH_ENCRYPTION
-    )
-target_link_libraries(libzippp PRIVATE
-    ${LIBZIP_LIBRARY}
-    ${ZLIB_LIBRARY}
-    )
-
-set_target_properties(libzippp PROPERTIES FOLDER "Dependencies/")

cmake/minhook.cmake

@@ -1,16 +0,0 @@
-include_guard()
-include(FetchContent)
-
-FetchContent_Declare(
-    minhook
-    GIT_REPOSITORY https://github.com/TsudaKageyu/minhook
-    GIT_TAG master)
-FetchContent_GetProperties(minhook)
-
-if (NOT minhook_POPULATED)
-    FetchContent_Populate(minhook)
-endif()
-
-add_subdirectory(${minhook_SOURCE_DIR} EXCLUDE_FROM_ALL)
-
-set_target_properties(minhook PROPERTIES FOLDER "Dependencies/")

cmake/msgsl.cmake

@@ -1,11 +0,0 @@
-cmake_minimum_required(VERSION 3.14)
-
-include(FetchContent)
-
-FetchContent_Declare(GSL
-    GIT_REPOSITORY "https://github.com/microsoft/GSL"
-    GIT_TAG "v4.0.0"
-    GIT_SHALLOW ON
-)
-
-FetchContent_MakeAvailable(GSL)

cmake/zlib.cmake

@@ -1,47 +0,0 @@
-include_guard()
-include(FetchContent)
-
-# Fetch zlib using FetchContent
-FetchContent_Declare(
-  zlib
-  GIT_REPOSITORY https://github.com/madler/zlib
-  GIT_TAG v1.3
-)
-
-FetchContent_GetProperties(zlib)
-
-if(zlib_POPULATED)
-    message(STATUS "Skipping zlib download")
-    return()
-endif()
-
-FetchContent_Populate(zlib)
-
-if(EXISTS ${CMAKE_INSTALL_PREFIX}/lib/zlibstatic.lib)
-    message(STATUS "Skipping zlib build")
-    return()
-endif()
-
-set(OPTIONS
-    "-A" "Win32"
-    "-DBUILD_SHARED_LIBS=OFF"
-    "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
-    "-DCMAKE_MSVC_RUNTIME_LIBRARY=${CMAKE_MSVC_RUNTIME_LIBRARY}"
-)
-    
-message("Building zlib with OPTIONS:\n${OPTIONS}")
-
-execute_process(
-    COMMAND ${CMAKE_COMMAND} ${OPTIONS} .
-    WORKING_DIRECTORY ${zlib_SOURCE_DIR}
-)
-execute_process(
-    COMMAND ${CMAKE_COMMAND} --build . --config Release
-    WORKING_DIRECTORY ${zlib_SOURCE_DIR}
-)
-execute_process(
-    COMMAND ${CMAKE_COMMAND} --install . --config Release
-    WORKING_DIRECTORY ${zlib_SOURCE_DIR}
-)
-
-message(STATUS "Finished zlib build")

header/Defines.h

@@ -1,7 +1,27 @@
 #pragma once
 
-//#define HashType DWORD64
-using HashType = DWORD32;
+//using HashType = DWORD32;
+using HashType = DWORD64;
+
+struct HashTuple {
+    HashType crc32;
+    HashType crc64;
+
+    bool operator==(const HashTuple& other) const noexcept
+    {
+        return (other.crc32 == crc32) || (other.crc64 == crc64);
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return crc32 != 0 || crc64 != 0;
+    }
+
+    explicit operator HashType() const noexcept
+    {
+        return crc32 ? crc32 : crc64;
+    }
+};
 
 struct TexEntry {
     std::vector<BYTE> data{};
@@ -14,21 +34,11 @@ struct TextureFileStruct {
     HashType crc_hash = 0; // hash value
 };
 
-inline void Message(const char* format, ...)
-{
-#ifdef _DEBUG
-#if 0
-    va_list args;
-    va_start(args, format);
-    vprintf(format, args);
-    va_end(args);
-#endif
-#endif
-}
-
-inline void Info(const char* format, ...)
+inline void Message([[maybe_unused]] const char* format, ...)
 {
 #ifdef _DEBUG
+    //const HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+    //[[maybe_unused]] const auto success = SetConsoleTextAttribute(hConsole, 0); // white
     va_list args;
     va_start(args, format);
     vprintf(format, args);
@@ -36,15 +46,26 @@ inline void Info(const char* format, ...)
 #endif
 }
 
-inline void Warning(const char* format, ...)
+inline void Info([[maybe_unused]] const char* format, ...)
 {
 #ifdef _DEBUG
-    static HANDLE hConsole = GetStdHandle(STD_ERROR_HANDLE);
-    [[maybe_unused]] static auto success = SetConsoleTextAttribute(hConsole, 6);
+    //const HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+    //[[maybe_unused]] const auto success = SetConsoleTextAttribute(hConsole, 0); // white
+    va_list args;
+    va_start(args, format);
+    vprintf(format, args);
+    va_end(args);
+#endif
+}
+
+inline void Warning([[maybe_unused]] const char* format, ...)
+{
+#ifdef _DEBUG
+    const HANDLE hConsole = GetStdHandle(STD_ERROR_HANDLE);
+    [[maybe_unused]] const auto success = SetConsoleTextAttribute(hConsole, 6); // yellow
     va_list args;
     va_start(args, format);
     vfprintf(stderr, format, args);
     va_end(args);
 #endif
 }
-

header/Main.h

@@ -32,3 +32,4 @@
 
 extern unsigned int gl_ErrorState;
 extern HINSTANCE gl_hThisInstance;
+inline std::filesystem::path gmod_dll_path;

header/Utils.h

@@ -12,4 +12,17 @@ namespace utils
             vec.erase(found);
         }
     }
+
+    inline std::wstring utf8_to_wstring(const std::string& utf8str) {
+        if (utf8str.empty()) return {};
+
+        // Calculate the number of wide characters needed for the conversion
+        const int count = MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), -1, nullptr, 0);
+        if (count == 0) throw std::runtime_error("Failed to convert UTF-8 to UTF-16");
+
+        std::wstring wstr(count, 0);
+        MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), -1, wstr.data(), count);
+
+        return wstr;
+    }
 }

header/uMod_IDirect3DCubeTexture9.h

@@ -2,23 +2,20 @@
 
 #include <d3d9.h>
 
-interface uMod_IDirect3DCubeTexture9 :  IDirect3DCubeTexture9 {
+interface uMod_IDirect3DCubeTexture9 : IDirect3DCubeTexture9 {
     uMod_IDirect3DCubeTexture9(IDirect3DCubeTexture9** ppTex, IDirect3DDevice9* pIDirect3DDevice9)
-    {
-        m_D3Dtex = *ppTex; //Texture which will be displayed and will be passed to the game
-        m_D3Ddev = pIDirect3DDevice9; //device pointer
-        CrossRef_D3Dtex = nullptr; //cross reference
-        // fake texture: store the pointer to the original uMod_IDirect3DCubeTexture9 object, needed if a fake texture is unselected
-        // original texture: stores the pointer to the fake texture object, is needed if original texture is deleted,
-        // thus the fake texture can also be deleted
-    }
+        : m_D3Dtex(*ppTex),
+          m_D3Ddev(pIDirect3DDevice9)
+    {}
+
+    virtual ~uMod_IDirect3DCubeTexture9() = default;
 
     // callback interface
     IDirect3DCubeTexture9* m_D3Dtex = nullptr;
     uMod_IDirect3DCubeTexture9* CrossRef_D3Dtex = nullptr;
     IDirect3DDevice9* m_D3Ddev = nullptr;
     TextureFileStruct* Reference = nullptr;
-    HashType Hash = 0u;
+    HashTuple Hash = {};
     bool FAKE = false;
 
     // original interface
@@ -47,5 +44,5 @@ interface uMod_IDirect3DCubeTexture9 :  IDirect3DCubeTexture9 {
     STDMETHOD(UnlockRect)(D3DCUBEMAP_FACES FaceType, UINT Level) override;
 
 
-    [[nodiscard]] HashType GetHash() const;
+    [[nodiscard]] HashTuple GetHash() const;
 };

header/uMod_IDirect3DTexture9.h

@@ -1,27 +1,23 @@
 #pragma once
 
 #include <d3d9.h>
-struct TextureFileStruct;
-interface uMod_IDirect3DTexture9 : public IDirect3DTexture9 {
-    uMod_IDirect3DTexture9(IDirect3DTexture9** ppTex, IDirect3DDevice9* pIDirect3DDevice9)
-    {
-        m_D3Dtex = *ppTex; //Texture which will be displayed and will be passed to the game
-        m_D3Ddev = pIDirect3DDevice9; //device pointer
-        // fake texture: store the pointer to the original uMod_IDirect3DTexture9 object, needed if a fake texture is unselected
-        // original texture: stores the pointer to the fake texture object, is needed if original texture is deleted,
-        // thus the fake texture can also be deleted
-    }
-    virtual ~uMod_IDirect3DTexture9()
-    {
+#include "Defines.h"
 
-    }
+struct TextureFileStruct;
+interface uMod_IDirect3DTexture9 : IDirect3DTexture9 {
+    uMod_IDirect3DTexture9(IDirect3DTexture9** ppTex, IDirect3DDevice9* pIDirect3DDevice9)
+        : m_D3Dtex(*ppTex),
+          m_D3Ddev(pIDirect3DDevice9)
+    {}
+
+    virtual ~uMod_IDirect3DTexture9() = default;
 
     // callback interface
     IDirect3DTexture9* m_D3Dtex = nullptr;
     uMod_IDirect3DTexture9* CrossRef_D3Dtex = nullptr;
     IDirect3DDevice9* m_D3Ddev = nullptr;
     TextureFileStruct* Reference = nullptr;
-    HashType Hash = 0u;
+    HashTuple Hash = {};
     bool FAKE = false;
 
     // original interface
@@ -48,5 +44,5 @@ interface uMod_IDirect3DTexture9 : public IDirect3DTexture9 {
     STDMETHOD(UnlockRect)(UINT Level) override;
     STDMETHOD(AddDirtyRect)(CONST RECT* pDirtyRect) override;
 
-    [[nodiscard]] HashType GetHash() const;
+    [[nodiscard]] HashTuple GetHash() const;
 };

header/uMod_IDirect3DVolumeTexture9.h

@@ -4,21 +4,18 @@
 
 interface uMod_IDirect3DVolumeTexture9 : IDirect3DVolumeTexture9 {
     uMod_IDirect3DVolumeTexture9(IDirect3DVolumeTexture9** ppTex, IDirect3DDevice9* pIDirect3DDevice9)
-    {
-        m_D3Dtex = *ppTex; //Texture which will be displayed and will be passed to the game
-        m_D3Ddev = pIDirect3DDevice9; //device pointer
-        CrossRef_D3Dtex = nullptr; //cross reference
-        // fake texture: store the pointer to the original uMod_IDirect3DVolumeTexture9 object, needed if a fake texture is unselected
-        // original texture: stores the pointer to the fake texture object, is needed if original texture is deleted,
-        // thus the fake texture can also be deleted
-    }
+        : m_D3Dtex(*ppTex),
+          m_D3Ddev(pIDirect3DDevice9)
+    {}
+
+    virtual ~uMod_IDirect3DVolumeTexture9() = default;
 
     // callback interface
     IDirect3DVolumeTexture9* m_D3Dtex = nullptr;
     uMod_IDirect3DVolumeTexture9* CrossRef_D3Dtex = nullptr;
     IDirect3DDevice9* m_D3Ddev = nullptr;
     TextureFileStruct* Reference = nullptr;
-    HashType Hash = 0u;
+    HashTuple Hash = {};
     bool FAKE = false;
 
     // original interface
@@ -46,5 +43,5 @@ interface uMod_IDirect3DVolumeTexture9 : IDirect3DVolumeTexture9 {
     STDMETHOD(UnlockBox)(UINT Level) override;
 
 
-    [[nodiscard]] HashType GetHash() const;
+    [[nodiscard]] HashTuple GetHash() const;
 };

modules/ModfileLoader.ixx

@@ -5,17 +5,47 @@ module;
 
 export module ModfileLoader;
 
-import <intsafe.h>;
-import <vector>;
-import <string>;
+import std;
 import <libzippp.h>;
-import <regex>;
-import <algorithm>;
-import <filesystem>;
 import ModfileLoader.TpfReader;
+import TextureFunction;
+
+namespace {
+    bool use_64_bit_crc = false;
+
+    HashType GetCrcFromFilename(const std::string& filename) {
+        const static std::regex re(R"(0[xX][0-9a-fA-F]{4,16})", std::regex::optimize);
+        std::smatch match;
+        if (!std::regex_search(filename, match, re)) {
+            return 0;
+        }
+
+        uint64_t crc64_hash = 0;
+        const auto number_str = match.str();
+        try {
+            crc64_hash = std::stoull(number_str, nullptr, 16);
+        }
+        catch (const std::invalid_argument&) {
+            Warning("Failed to parse %s as a hash\n", filename.c_str());
+            return 0;
+        }
+        catch (const std::out_of_range&) {
+            Warning("Out of range while parsing %s as a hash\n", filename.c_str());
+            return 0;
+        }
+        use_64_bit_crc = use_64_bit_crc || crc64_hash > 0xFFFFFFFF;
+        return crc64_hash;
+    }
+}
+
+namespace HashCheck {
+    export bool Use64BitCrc() {
+        return use_64_bit_crc;
+    }
+}
 
 export class ModfileLoader {
-    std::string file_name;
+    std::filesystem::path file_name;
     const std::string TPF_PASSWORD{
         0x73, 0x2A, 0x63, 0x7D, 0x5F, 0x0A, static_cast<char>(0xA6), static_cast<char>(0xBD),
         0x7D, 0x65, 0x7E, 0x67, 0x61, 0x2A, 0x7F, 0x7F,
@@ -26,28 +56,28 @@ export class ModfileLoader {
     };
 
 public:
-    ModfileLoader(const std::string& fileName);
+    ModfileLoader(const std::filesystem::path& fileName);
 
-    std::vector<TexEntry> GetContents();
+    std::vector<TexEntry> GetContents() const;
 
 private:
 
-    std::vector<TexEntry> GetTpfContents();
+    std::vector<TexEntry> GetTpfContents() const;
 
-    std::vector<TexEntry> GetFileContents();
+    std::vector<TexEntry> GetFileContents() const;
 
-    void LoadEntries(libzippp::ZipArchive& archive, std::vector<TexEntry>& entries);
+    static void LoadEntries(libzippp::ZipArchive& archive, std::vector<TexEntry>& entries);
 };
 
-ModfileLoader::ModfileLoader(const std::string& fileName)
+ModfileLoader::ModfileLoader(const std::filesystem::path& fileName)
 {
-    file_name = std::filesystem::absolute(fileName).string();
+    file_name = std::filesystem::absolute(fileName);
 }
 
-std::vector<TexEntry> ModfileLoader::GetContents()
+std::vector<TexEntry> ModfileLoader::GetContents() const
 {
     try {
-        return file_name.ends_with(".tpf") ? GetTpfContents() : GetFileContents();
+        return file_name.wstring().ends_with(L".tpf") ? GetTpfContents() : GetFileContents();
     }
     catch (const std::exception&) {
         Warning("Failed to open mod file: %s\n", file_name.c_str());
@@ -55,7 +85,7 @@ std::vector<TexEntry> ModfileLoader::GetContents()
     return {};
 }
 
-std::vector<TexEntry> ModfileLoader::GetTpfContents()
+std::vector<TexEntry> ModfileLoader::GetTpfContents() const
 {
     std::vector<TexEntry> entries;
     auto tpf_reader = TpfReader(file_name);
@@ -77,11 +107,11 @@ std::vector<TexEntry> ModfileLoader::GetTpfContents()
     return entries;
 }
 
-std::vector<TexEntry> ModfileLoader::GetFileContents()
+std::vector<TexEntry> ModfileLoader::GetFileContents() const
 {
     std::vector<TexEntry> entries;
 
-    libzippp::ZipArchive zip_archive(file_name);
+    libzippp::ZipArchive zip_archive(file_name.string());
     zip_archive.open();
     LoadEntries(zip_archive, entries);
     zip_archive.close();
@@ -92,36 +122,20 @@ std::vector<TexEntry> ModfileLoader::GetFileContents()
 void ParseSimpleArchive(const libzippp::ZipArchive& archive, std::vector<TexEntry>& entries)
 {
     for (const auto& entry : archive.getEntries()) {
-        if (entry.isFile()) {
-            //TODO: #6 - Implement regex search
-            auto name = entry.getName();
-
-            const static std::regex re(R"(0x[0-9a-f]{4,8})", std::regex::optimize | std::regex::icase);
-            std::smatch match;
-            if (!std::regex_search(name, match, re)) {
-                continue;
-            }
-
-            uint32_t crc_hash;
-             try {
-                crc_hash = std::stoul(match.str(), nullptr, 16);
-            }
-            catch (const std::invalid_argument&) {
-                Warning("Failed to parse %s as a hash", name.c_str());
-                continue;
-            }
-            catch (const std::out_of_range&) {
-                Message("Out of range while parsing %s as a hash", name.c_str());
-                continue;
-            }
-
-            const auto data_ptr = static_cast<BYTE*>(entry.readAsBinary());
-            const auto size = entry.getSize();
-            std::vector vec(data_ptr, data_ptr + size);
-            std::filesystem::path tex_name(entry.getName());
-            entries.emplace_back(std::move(vec), crc_hash, tex_name.extension().string());
-            delete[] data_ptr;
+        if (!entry.isFile())
+            continue;
+        const auto entry_name = entry.getName();
+        const auto crc_hash = GetCrcFromFilename(entry.getName());
+        if (!crc_hash) {
+            Warning("Entry with name %s could not be parsed", entry_name.c_str());
+            continue;
         }
+        const auto data_ptr = static_cast<BYTE*>(entry.readAsBinary());
+        const auto size = entry.getSize();
+        std::vector vec(data_ptr, data_ptr + size);
+        std::filesystem::path tex_name(entry.getName());
+        entries.emplace_back(std::move(vec), crc_hash, tex_name.extension().string());
+        delete[] data_ptr;
     }
 }
 
@@ -132,29 +146,20 @@ void ParseTexmodArchive(std::vector<std::string>& lines, libzippp::ZipArchive& a
         // match[1] | match[2]
         const static auto address_file_regex = std::regex(R"(^[\\/.]*([^|]+)\|([^\r\n]+))", std::regex::optimize);
         std::smatch match;
-        std::regex_search(line, match, address_file_regex);
-        if (match.size() != 3u)
+        if (!std::regex_search(line, match, address_file_regex)) {
+            Warning("Failed to parse texmod.def archive line: %s - %s", line.c_str(), line.c_str());
             continue;
+        }
         const auto address_string = match[1].str();
         const auto file_path = match[2].str();
 
-        const auto entry = archive.getEntry(file_path);
-        if (entry.isNull() || !entry.isFile()) {
+        const auto crc_hash = GetCrcFromFilename(address_string);
+        if (!crc_hash)
             continue;
-        }
 
-        uint32_t crc_hash{};
-        try {
-            crc_hash = std::stoul(address_string, nullptr, 16);
-        }
-        catch (const std::invalid_argument&) {
-            Warning("Failed to parse %s as a hash", address_string.c_str());
+        const auto entry = archive.getEntry(file_path);
+        if (entry.isNull() || !entry.isFile())
             continue;
-        }
-        catch (const std::out_of_range&) {
-            Warning("Out of range while parsing %s as a hash", address_string.c_str());
-            continue;
-        }
 
         const auto data_ptr = static_cast<BYTE*>(entry.readAsBinary());
         const auto size = static_cast<size_t>(entry.getSize());

modules/ModfileLoader_TpfReader.ixx

@@ -1,12 +1,10 @@
 export module ModfileLoader.TpfReader;
 
-import <string>;
-import <fstream>;
-import <vector>;
+import std;
 
 export class TpfReader {
 public:
-    TpfReader(const std::string& path)
+    TpfReader(const std::filesystem::path& path)
     {
         file_stream = std::ifstream(path, std::ios::binary);
         if (!file_stream.seekg(0, std::ios::end).good() || !file_stream.seekg(0, std::ios::beg).good()) {
@@ -25,13 +23,13 @@ public:
         line_length = file_stream.tellg();
         file_stream.seekg(0, std::ios::beg); // Go to the beginning of the stream
 
-        std::vector<char> data(line_length);
+        std::vector<char> data(static_cast<long>(line_length));
         file_stream.read(data.data(), line_length);
-        for (auto i = 0; i < data.size(); i++) {
+        for (auto i = 0u; i < data.size(); i++) {
             data[i] = XOR(data[i], i);
         }
 
-        for (int i = data.size() - 1; i > 0 && data[i] != 0; i--) {
+        for (auto i = data.size() - 1; i > 0 && data[i] != 0; i--) {
             data[i] = 0;
         }
 
@@ -44,11 +42,11 @@ public:
 
 private:
     std::ifstream file_stream;
-    long line_length;
+    std::streamoff line_length = 0;
 
     [[nodiscard]] char XOR(const char b, const long position) const
     {
-        if (position > line_length - 4) {
+        if (position >= (line_length / 4) * 4) {
             return b ^ TPF_XOREven;
         }
 

modules/TextureClient.ixx

@@ -10,6 +10,7 @@ export module TextureClient;
 import TextureFunction;
 import ModfileLoader;
 
+export std::vector<std::pair<std::string, std::string>> modlists_contents;
 /*
  *  An object of this class is owned by each d3d9 device.
  *  All other functions are called from the render thread instance of the game itself.
@@ -34,7 +35,6 @@ public:
     std::vector<uMod_IDirect3DCubeTexture9*> OriginalCubeTextures;
     // stores the pointer to the uMod_IDirect3DCubeTexture9 objects created by the game
 
-
 private:
     IDirect3DDevice9* D3D9Device;
     // Cached info about whether this id a dx9ex device or not; used for proxy functions
@@ -57,8 +57,7 @@ private:
     // called if a target texture is found
     int LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtrPtr auto ppTexture);
 
-    void LoadModsFromFile(const char* source);
-    std::filesystem::path exe_path; // path to gw.exe
+    void LoadModsFromModlist(std::pair<std::string, std::string> modfile_tuple);
     std::filesystem::path dll_path; // path to gmod dll
 };
 
@@ -155,20 +154,21 @@ int TextureClient::UnlockMutex()
     return RETURN_OK;
 }
 
-gsl::owner<TextureFileStruct*> AddFile(TexEntry& entry, const bool compress, const std::filesystem::path& dll_path)
+gsl::owner<TextureFileStruct*> AddFile(TexEntry& entry, const bool compress)
 {
     const auto texture_file_struct = new TextureFileStruct();
     texture_file_struct->crc_hash = entry.crc_hash;
-    const auto dds_blob = TextureFunction::ConvertToCompressedDDS(entry, compress, dll_path);
+    const auto dds_blob = TextureFunction::ConvertToCompressedDDS(entry, compress);
     texture_file_struct->data.assign(static_cast<BYTE*>(dds_blob.GetBufferPointer()), static_cast<BYTE*>(dds_blob.GetBufferPointer()) + dds_blob.GetBufferSize());
     return texture_file_struct;
 }
 
-std::vector<gsl::owner<TextureFileStruct*>> ProcessModfile(const std::string& modfile, const std::filesystem::path& dll_path, const bool compress)
+std::vector<gsl::owner<TextureFileStruct*>> ProcessModfile(const std::filesystem::path& modfile, const bool compress)
 {
     const auto hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
     if (FAILED(hr)) return {};
-    Message("Initialize: loading file %s... ", modfile.c_str());
+    const auto modfile_str = modfile.string();
+    Message("Initialize: loading file %s... ", modfile_str.c_str());
     auto file_loader = ModfileLoader(modfile);
     auto entries = file_loader.GetContents();
     if (entries.empty()) {
@@ -180,7 +180,7 @@ std::vector<gsl::owner<TextureFileStruct*>> ProcessModfile(const std::string& mo
     texture_file_structs.reserve(entries.size());
     unsigned file_bytes_loaded = 0;
     for (auto& tpf_entry : entries) {
-        const auto tex_file_struct = AddFile(tpf_entry, compress, dll_path);
+        const auto tex_file_struct = AddFile(tpf_entry, compress);
         texture_file_structs.push_back(tex_file_struct);
         file_bytes_loaded += texture_file_structs.back()->data.size();
     }
@@ -190,30 +190,31 @@ std::vector<gsl::owner<TextureFileStruct*>> ProcessModfile(const std::string& mo
     return texture_file_structs;
 }
 
-void TextureClient::LoadModsFromFile(const char* source)
+void TextureClient::LoadModsFromModlist(std::pair<std::string, std::string> modfile_tuple)
 {
-    static std::vector<std::string> loaded_modfiles{};
-    Message("Initialize: searching in %s\n", source);
+    static std::vector<std::filesystem::path> loaded_modfiles{};
 
-    std::ifstream file(source);
-    if (!file.is_open()) {
-        Warning("LoadModsFromFile: failed to open modlist.txt for reading; aborting!!!");
-        return;
-    }
-    Message("Initialize: found modlist.txt. Reading\n");
+    std::locale::global(std::locale(""));
+    std::istringstream file(modfile_tuple.second);
     std::string line;
-    std::vector<std::string> modfiles;
+    std::vector<std::filesystem::path> modfiles;
     while (std::getline(file, line)) {
+        if (line.starts_with("//") || line.starts_with("#") || line.empty()) {
+            continue;
+        }
         // Remove newline character
         line.erase(std::ranges::remove(line, '\r').begin(), line.end());
         line.erase(std::ranges::remove(line, '\n').begin(), line.end());
 
-        if (!std::ranges::contains(loaded_modfiles, line)) {
-            modfiles.push_back(line);
-            loaded_modfiles.push_back(line);
+        const auto wline = utils::utf8_to_wstring(line);
+        const auto fsline = std::filesystem::path(wline);
+
+        if (!std::ranges::contains(loaded_modfiles, fsline)) {
+            modfiles.push_back(fsline);
+            loaded_modfiles.push_back(fsline);
         }
     }
-    auto files_size = 0u;
+    auto files_size = 0ull;
     for (const auto modfile : modfiles) {
         if (std::filesystem::exists(modfile)) {
             files_size += std::filesystem::file_size(modfile);
@@ -221,7 +222,7 @@ void TextureClient::LoadModsFromFile(const char* source)
     }
     std::vector<std::future<std::vector<gsl::owner<TextureFileStruct*>>>> futures;
     for (const auto modfile : modfiles) {
-        futures.emplace_back(std::async(std::launch::async, ProcessModfile, modfile, dll_path, files_size > 400'000'000));
+        futures.emplace_back(std::async(std::launch::async, ProcessModfile, modfile, files_size > 400'000'000));
     }
     auto loaded_size = 0u;
     for (auto& future : futures) {
@@ -238,26 +239,15 @@ void TextureClient::LoadModsFromFile(const char* source)
         }
         should_update = true;
     }
-    Message("Finished loading mods from %s: Loaded %u bytes (%u mb)", source, loaded_size, loaded_size / 1024 / 1024);
+    Message("Finished loading mods from %s: Loaded %u bytes (%u mb)\n", modfile_tuple.first.c_str(), loaded_size, loaded_size / 1024 / 1024);
 }
 
 void TextureClient::Initialize()
 {
     const auto t1 = std::chrono::high_resolution_clock::now();
     Info("Initialize: begin\n");
-    Message("Initialize: searching for modlist.txt\n");
-    char gwpath[MAX_PATH]{};
-    GetModuleFileName(GetModuleHandle(nullptr), gwpath, MAX_PATH); //ask for name and path of this executable
-    char dllpath[MAX_PATH]{};
-    GetModuleFileName(gl_hThisInstance, dllpath, MAX_PATH); //ask for name and path of this dll
-    exe_path = std::filesystem::path(gwpath).parent_path();
-    dll_path = std::filesystem::path(dllpath).parent_path();
-    for (const auto& path : {exe_path, dll_path}) {
-        const auto modlist = path / "modlist.txt";
-        if (std::filesystem::exists(modlist)) {
-            Message("Initialize: found %s\n", modlist.string().c_str());
-            LoadModsFromFile(modlist.string().c_str());
-        }
+    for (const auto& modlists_content : modlists_contents) {
+        LoadModsFromModlist(modlists_content);
     }
     const auto t2 = std::chrono::high_resolution_clock::now();
     const auto ms = duration_cast<std::chrono::milliseconds>(t2 - t1);
@@ -330,15 +320,16 @@ int TextureClient::RemoveTexture(uModTexturePtr auto pTexture)
 
 int TextureClient::LookUpToMod(uModTexturePtr auto pTexture)
 {
-    Message("TextureClient::LookUpToMod( %p): hash: %#lX,  %p\n", pTexture, pTexture->Hash, this);
+    Message("TextureClient::LookUpToMod( %p): hash: %#lX\n", pTexture, pTexture->Hash);
     int ret = RETURN_OK;
 
     if (pTexture->CrossRef_D3Dtex != nullptr)
         return ret; // bug, this texture is already switched
 
-    const auto found = modded_textures.find(pTexture->Hash);
+    auto found = modded_textures.find(pTexture->Hash.crc32);
     if (found == modded_textures.end())
-        return ret;
+        if (found = modded_textures.find(pTexture->Hash.crc64), !pTexture->Hash.crc64 || found == modded_textures.end())
+            return ret;
 
     const auto textureFileStruct = found->second;
 

modules/TextureFunction.ixx

@@ -45,15 +45,114 @@ int SwitchTextures(T pTexture1, T pTexture2)
     return RETURN_TEXTURE_NOT_SWITCHED;
 }
 
+constexpr auto crctab64 = std::to_array({
+  0x0000000000000000ULL, 0x7ad870c830358979ULL, 0xf5b0e190606b12f2ULL,
+  0x8f689158505e9b8bULL, 0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL,
+  0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL, 0xab28ecb46814fe75ULL,
+  0xd1f09c7c5821770cULL, 0x5e980d24087fec87ULL, 0x24407dec384a65feULL,
+  0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL, 0x9ea0e857903e5a08ULL,
+  0xe478989fa00bd371ULL, 0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL,
+  0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL, 0xbd301a4810ffd90eULL,
+  0xc7e86a8020ca5077ULL, 0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL,
+  0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL, 0x2390f21f80c18306ULL,
+  0x594882d7b0f40a7fULL, 0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL,
+  0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL, 0xfa11fe77117cdf02ULL,
+  0x80c98ebf2149567bULL, 0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL,
+  0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL, 0xcf99fa94e9567b7fULL,
+  0xb5418a5cd963f206ULL, 0x513912c379682177ULL, 0x2be1620b495da80eULL,
+  0xa489f35319033385ULL, 0xde51839b2936bafcULL, 0x9101f7b0e12997f8ULL,
+  0xebd98778d11c1e81ULL, 0x64b116208142850aULL, 0x1e6966e8b1770c73ULL,
+  0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL, 0x72a9e0dcf9a9a271ULL,
+  0x08719014c99c2b08ULL, 0x4721e43f0183060cULL, 0x3df994f731b68f75ULL,
+  0xb29105af61e814feULL, 0xc849756751dd9d87ULL, 0x2c31edf8f1d64ef6ULL,
+  0x56e99d30c1e3c78fULL, 0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL,
+  0xec09088b6997f879ULL, 0x96d1784359a27100ULL, 0x19b9e91b09fcea8bULL,
+  0x636199d339c963f2ULL, 0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL,
+  0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL, 0x1f423fcee22f9be0ULL,
+  0x659a4f06d21a1299ULL, 0xeaf2de5e82448912ULL, 0x902aae96b271006bULL,
+  0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL, 0x81e2d7997211c1e8ULL,
+  0xfb3aa75142244891ULL, 0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL,
+  0x41da32eaea507767ULL, 0x3b024222da65fe1eULL, 0xa2722586f2d042eeULL,
+  0xd8aa554ec2e5cb97ULL, 0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL,
+  0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL, 0x97fa21650afae693ULL,
+  0xed2251ad3acf6feaULL, 0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL,
+  0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL, 0xc9622c4102850a14ULL,
+  0xb3ba5c8932b0836dULL, 0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL,
+  0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL, 0xd0dbc55a0b79e09fULL,
+  0xaa03b5923b4c69e6ULL, 0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL,
+  0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL, 0x8e43c87e03060c18ULL,
+  0xf49bb8b633338561ULL, 0x7bf329ee636d1eeaULL, 0x012b592653589793ULL,
+  0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL, 0xbbcbcc9dfb2ca865ULL,
+  0xc113bc55cb19211cULL, 0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL,
+  0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL, 0x985b3e827bed2b63ULL,
+  0xe2834e4a4bd8a21aULL, 0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL,
+  0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL, 0x06fbd6d5ebd3716bULL,
+  0x7c23a61ddbe6f812ULL, 0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL,
+  0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL, 0x95ac9329ac4bc9b5ULL,
+  0xef74e3e19c7e40ccULL, 0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL,
+  0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL, 0xa02497ca54616dc8ULL,
+  0xdafce7026454e4b1ULL, 0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL,
+  0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL, 0xfebc9aee5c1e814fULL,
+  0x8464ea266c2b0836ULL, 0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL,
+  0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL, 0x1d148d82449eb4c6ULL,
+  0x67ccfd4a74ab3dbfULL, 0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL,
+  0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL, 0x438c80a64ce15841ULL,
+  0x3954f06e7cd4d138ULL, 0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL,
+  0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL, 0x76048445b4cbfc3cULL,
+  0x0cdcf48d84fe7545ULL, 0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL,
+  0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL, 0xaf85882d2576a038ULL,
+  0xd55df8e515432941ULL, 0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL,
+  0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL, 0x3125607ab548fa30ULL,
+  0x4bfd10b2857d7349ULL, 0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL,
+  0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL, 0x12b5926535897936ULL,
+  0x686de2ad05bcf04fULL, 0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL,
+  0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL, 0x273d9686cda3dd4bULL,
+  0x5de5e64efd965432ULL, 0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL,
+  0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL, 0x79a59ba2c5dc31ccULL,
+  0x037deb6af5e9b8b5ULL, 0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL,
+  0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL, 0xbf66a804b64ef628ULL,
+  0xc5bed8cc867b7f51ULL, 0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL,
+  0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL, 0xe1fea520be311aafULL,
+  0x9b26d5e88e0493d6ULL, 0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL,
+  0x21c640532670ac20ULL, 0x5b1e309b16452559ULL, 0xd476a1c3461bbed2ULL,
+  0xaeaed10b762e37abULL, 0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL,
+  0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL, 0xf7e653dcc6da3dd4ULL,
+  0x8d3e2314f6efb4adULL, 0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL,
+  0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL, 0x6946bb8b56e467dcULL,
+  0x139ecb4366d1eea5ULL, 0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL,
+  0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL, 0xb0c7b7e3c7593bd8ULL,
+  0xca1fc72bf76cb2a1ULL, 0x45775673a732292aULL, 0x3faf26bb9707a053ULL,
+  0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL, 0x854fb3003f739fa5ULL,
+  0xff97c3c80f4616dcULL, 0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL,
+  0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL, 0xdbd7be24370c7322ULL,
+  0xa10fceec0739fa5bULL, 0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL,
+  0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL, 0x387fa9482f8c46abULL,
+  0x42a7d9801fb9cfd2ULL, 0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL,
+  0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL, 0x66e7a46c27f3aa2cULL,
+  0x1c3fd4a417c62355ULL, 0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL,
+  0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL, 0x536fa08fdfd90e51ULL,
+  0x29b7d047efec8728ULL
+});
+
 export namespace TextureFunction {
 
-    unsigned int GetCRC32(char* pcDatabuf, unsigned int ulDatalen)
+    uint64_t get_crc64(const char* data, unsigned int length) {
+        uint64_t crc = 0xFFFFFFFFFFFFFFFFULL;
+
+        while (length--) {
+            crc = crctab64[(crc ^ *data++) & 0xFF] ^ (crc >> 8);
+        }
+
+        return crc;
+    }
+
+    uint32_t get_crc32(const char* data_ptr, const unsigned int length)
     {
         constexpr static auto crc32_poly = 0xEDB88320u;
         constexpr static auto ul_crc_in = 0xffffffff;
         unsigned int crc = ul_crc_in;
-        for (unsigned int idx = 0u; idx < ulDatalen; idx++) {
-            unsigned int data = *pcDatabuf++;
+        for (unsigned int idx = 0u; idx < length; idx++) {
+            unsigned int data = *data_ptr++;
             for (unsigned int bit = 0u; bit < 8u; bit++, data >>= 1) {
                 crc = crc >> 1 ^ ((crc ^ data) & 1 ? crc32_poly : 0);
             }
@@ -239,10 +338,10 @@ export namespace TextureFunction {
         return compressed_image;
     }
 
-    void ImageSave(const DirectX::ScratchImage& image, const TexEntry& entry, const std::filesystem::path& dll_path)
+    void ImageSave(const DirectX::ScratchImage& image, const TexEntry& entry)
     {
         const auto file_name = std::format("0x{:x}.dds", entry.crc_hash);
-        const auto file_out = dll_path / "textures" / file_name;
+        const auto file_out = gmod_dll_path.parent_path() / "textures" / file_name;
         try {
             if (std::filesystem::exists(file_out)) {
                 return;
@@ -262,11 +361,10 @@ export namespace TextureFunction {
         }
         catch (const std::exception& e) {
             Warning("SaveDDSImageToDisk (%#lX%s): %s\n", entry.crc_hash, entry.ext.c_str(), e.what());
-            return;
         }
     }
 
-    DirectX::Blob ConvertToCompressedDDS(TexEntry& entry, const bool compress, const std::filesystem::path& dll_path)
+    DirectX::Blob ConvertToCompressedDDS(TexEntry& entry, const bool compress)
     {
         DirectX::ScratchImage image;
         HRESULT hr = 0;
@@ -283,12 +381,7 @@ export namespace TextureFunction {
         else {
             hr = DirectX::LoadFromWICMemory(entry.data.data(), entry.data.size(), DirectX::WIC_FLAGS_NONE, nullptr, image);
             if (image.GetMetadata().format == DXGI_FORMAT_B8G8R8X8_UNORM) {
-                // todo: this is undefined behaviour, but we must force them to be interpreted as BGRA instead of BGRX
-                const_cast<DXGI_FORMAT&>(image.GetMetadata().format) = DXGI_FORMAT_B8G8R8A8_UNORM;
-                const auto images = image.GetImages();
-                for (int i = 0; i < image.GetImageCount(); ++i) {
-                    const_cast<DXGI_FORMAT&>(images[i].format) = DXGI_FORMAT_B8G8R8A8_UNORM;
-                }
+                image.OverrideFormat(DXGI_FORMAT_B8G8R8A8_UNORM);
             }
         }
         entry.data.clear();
@@ -314,7 +407,7 @@ export namespace TextureFunction {
         }
 
     #ifdef _DEBUG
-        ImageSave(compressed_image, entry, dll_path);
+        ImageSave(compressed_image, entry);
     #endif
         return dds_blob;
     }

source/Error.cpp

@@ -16,7 +16,7 @@ const char *function)
         GetModuleFileName(gl_hThisInstance, module_path, _countof(module_path));
     }
     if (!*module_path) {
-        strcpy(module_path, "Unknown");
+        strcpy_s(module_path, "Unknown");
     }
     const char* fmt = "Module: %s\n\nExpr: %s\n\nFile: %s\n\nFunction: %s, line %d";
     int len = snprintf(NULL, 0, fmt, module_path, expr, file, function, line);

source/dll_main.cpp

@@ -2,6 +2,8 @@
 #include <Psapi.h>
 #include "MinHook.h"
 
+import TextureClient;
+
 void ExitInstance();
 void InitInstance(HINSTANCE hModule);
 
@@ -44,7 +46,7 @@ namespace {
             TCHAR szModuleName[MAX_PATH];
             ASSERT(GetModuleFileName(hModules[i], szModuleName, _countof(szModuleName)) > 0);
             const auto basename = strrchr(szModuleName, '\\');
-            if (basename && stricmp(basename + 1, name) == 0)
+            if (basename && _stricmp(basename + 1, name) == 0)
                 return hModules[i];
         }
         return nullptr;
@@ -183,6 +185,9 @@ BOOL WINAPI DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
     switch (ul_reason_for_call) {
         case DLL_PROCESS_ATTACH: {
 #ifdef _DEBUG
+            wchar_t dllFilePath[512 + 1]{};
+            GetModuleFileNameW(hModule, dllFilePath, 512);
+            gmod_dll_path = dllFilePath;
             AllocConsole();
             SetConsoleTitleA("gMod Console");
             freopen_s(&stdout_proxy, "CONOUT$", "w", stdout);
@@ -201,17 +206,40 @@ BOOL WINAPI DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
     return true;
 }
 
+void LoadModlists()
+{
+    Message("Initialize: searching for modlist.txt\n");
+    char gwpath[MAX_PATH]{};
+    GetModuleFileName(GetModuleHandle(nullptr), gwpath, MAX_PATH); //ask for name and path of this executable
+    char dllpath[MAX_PATH]{};
+    GetModuleFileName(gl_hThisInstance, dllpath, MAX_PATH); //ask for name and path of this dll
+    const auto exe_path = std::filesystem::path(gwpath).parent_path();
+    const auto dll_path = std::filesystem::path(dllpath).parent_path();
+    for (const auto& path : {exe_path, dll_path}) {
+        const auto modlist = path / "modlist.txt";
+        if (std::filesystem::exists(modlist)) {
+            Message("Initialize: found %s\n", modlist.string().c_str());
+            std::ifstream t(modlist, std::ios::binary);
+            std::stringstream buffer;
+            buffer << t.rdbuf();
+            modlists_contents.emplace_back(modlist.string(), buffer.str());
+        }
+    }
+}
+
 void InitInstance(HINSTANCE hModule)
 {
     Message("InitInstance: %p\n", hModule);
-    DisableThreadLibraryCalls(hModule); //reduce overhead
 
     // Store the handle to this module
     gl_hThisInstance = hModule;
 
+    LoadModlists();
+    DisableThreadLibraryCalls(hModule); //reduce overhead
+
     // d3d9.dll shouldn't be loaded at this point.
-    const auto d3d9_loaded = FindLoadedModuleByName("d3d9.dll");
-    ASSERT(!d3d9_loaded);
+    [[maybe_unused]] const auto d3d9_loaded = FindLoadedModuleByName("d3d9.dll");
+    //ASSERT(!d3d9_loaded);
 
     MH_Initialize();
 

source/uMod_IDirect3DCubeTexture9.cpp

@@ -1,7 +1,8 @@
 #include "Main.h"
 
-import TextureFunction;
+import ModfileLoader;
 import TextureClient;
+import TextureFunction;
 
 //this function yields for the non switched texture object
 HRESULT APIENTRY uMod_IDirect3DCubeTexture9::QueryInterface(REFIID riid, void** ppvObj)
@@ -227,10 +228,10 @@ HRESULT APIENTRY uMod_IDirect3DCubeTexture9::UnlockRect(D3DCUBEMAP_FACES FaceTyp
     return m_D3Dtex->UnlockRect(FaceType, Level);
 }
 
-HashType uMod_IDirect3DCubeTexture9::GetHash() const
+HashTuple uMod_IDirect3DCubeTexture9::GetHash() const
 {
     if (FAKE) {
-        return 0;
+        return {};
     }
     IDirect3DCubeTexture9* pTexture = m_D3Dtex;
     if (CrossRef_D3Dtex != nullptr) {
@@ -244,7 +245,7 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
         Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetLevelDesc \n");
-        return 0;
+        return {};
     }
 
     Message("uMod_IDirect3DCubeTexture9::GetHash() (%d %d) %d\n", desc.Width, desc.Height, desc.Format);
@@ -254,17 +255,18 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
         Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &pResolvedSurface) != D3D_OK) {
             Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetSurfaceLevel\n");
-            return 0;
+            return {};
         }
         if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
             Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 2\n");
-            return 0;
+            return {};
         }
     }
 
-    const int size = (TextureFunction::GetBitsFromFormat(desc.Format) * desc.Width * desc.Height) / 8;
-    const auto hash = TextureFunction::GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    const auto size = (TextureFunction::GetBitsFromFormat(desc.Format) * desc.Width * desc.Height) / 8;
+    const auto crc32 = TextureFunction::get_crc32(static_cast<char*>(d3dlr.pBits), size);
+    const auto crc64 = HashCheck::Use64BitCrc() ? TextureFunction::get_crc64(static_cast<char*>(d3dlr.pBits), size) : 0;
 
     // Only release surfaces after we're finished with d3dlr
     if (pResolvedSurface != nullptr) {
@@ -275,6 +277,7 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
         pTexture->UnlockRect(D3DCUBEMAP_FACE_POSITIVE_X, 0); //unlock the raw data
     }
 
-    Message("uMod_IDirect3DCubeTexture9::GetHash() %#lX (%d %d) %d = %d\n", hash, desc.Width, desc.Height, desc.Format, size);
-    return hash;
+    Message("uMod_IDirect3DCubeTexture9::GetHash() %#lX (%d %d) %d = %d\n", crc32, desc.Width, desc.Height, desc.Format, size);
+    Message("uMod_IDirect3DCubeTexture9::GetHash() %#llX (%d %d) %d = %d\n", crc64, desc.Width, desc.Height, desc.Format, size);
+    return {crc32, crc64};
 }

source/uMod_IDirect3DDevice9.cpp

@@ -66,7 +66,7 @@ ULONG uMod_IDirect3DDevice9::Release()
 
     const ULONG count = m_pIDirect3DDevice9->Release();
     Message("%p = " PRE_MESSAGE "::Release(): %p\n", count, this);
-    if (uMod_Reference != count) //bug
+    if (uMod_Reference != static_cast<int>(count)) //bug
     {
         Message("Error in " PRE_MESSAGE "::Release(): %p!=%p\n", uMod_Reference, count);
     }
@@ -275,10 +275,11 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
     uMod_IDirect3DCubeTexture9* pSourceCube = nullptr;
     IDirect3DBaseTexture9* cpy;
     if (pSourceTexture != nullptr) {
+        const auto hash = pSource->GetHash();
         switch (pSourceTexture->QueryInterface(IID_IDirect3D9, (void**)&cpy)) {
             case 0x01000000L: {
                 pSource = static_cast<uMod_IDirect3DTexture9*>(pSourceTexture);
-                if (const auto hash = pSource->GetHash()) {
+                if (hash) {
                     if (hash != pSource->Hash) // this hash has changed !!
                     {
                         pSource->Hash = hash;
@@ -303,7 +304,7 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
             }
             case 0x01000001L: {
                 pSourceVolume = static_cast<uMod_IDirect3DVolumeTexture9*>(pSourceTexture);
-                if (const auto hash = pSource->GetHash()) {
+                if (hash) {
                     if (hash != pSourceVolume->Hash) // this hash has changed !!
                     {
                         pSourceVolume->Hash = hash;
@@ -328,7 +329,7 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
             }
             case 0x01000002L: {
                 pSourceCube = static_cast<uMod_IDirect3DCubeTexture9*>(pSourceTexture);
-                if (const auto hash = pSourceCube->GetHash()) {
+                if (hash) {
                     if (hash != pSourceCube->Hash) // this hash has changed !!
                     {
                         pSourceCube->Hash = hash;
@@ -366,9 +367,9 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
                     pDest->Hash = pSource->Hash; // take over the hash
                     UnswitchTextures(pDest);
                     if (pSource->CrossRef_D3Dtex != nullptr) {
-                        uMod_IDirect3DTexture9* cpy = pSource->CrossRef_D3Dtex;
+                        uMod_IDirect3DTexture9* cpy2 = pSource->CrossRef_D3Dtex;
                         UnswitchTextures(pSource);
-                        SwitchTextures(cpy, pDest);
+                        SwitchTextures(cpy2, pDest);
                     }
                 }
                 if (pDest->CrossRef_D3Dtex != nullptr) {
@@ -386,9 +387,9 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
                     pDest->Hash = pSourceVolume->Hash; // take over the hash
                     UnswitchTextures(pDest);
                     if (pSourceVolume->CrossRef_D3Dtex != nullptr) {
-                        uMod_IDirect3DVolumeTexture9* cpy = pSourceVolume->CrossRef_D3Dtex;
+                        uMod_IDirect3DVolumeTexture9* cpy2 = pSourceVolume->CrossRef_D3Dtex;
                         UnswitchTextures(pSourceVolume);
-                        SwitchTextures(cpy, pDest);
+                        SwitchTextures(cpy2, pDest);
                     }
                 }
                 if (pDest->CrossRef_D3Dtex != nullptr) {
@@ -406,9 +407,9 @@ HRESULT uMod_IDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTextu
                     pDest->Hash = pSourceCube->Hash; // take over the hash
                     UnswitchTextures(pDest);
                     if (pSourceCube->CrossRef_D3Dtex != nullptr) {
-                        uMod_IDirect3DCubeTexture9* cpy = pSourceCube->CrossRef_D3Dtex;
+                        uMod_IDirect3DCubeTexture9* cpy2 = pSourceCube->CrossRef_D3Dtex;
                         UnswitchTextures(pSourceCube);
-                        SwitchTextures(cpy, pDest);
+                        SwitchTextures(cpy2, pDest);
                     }
                 }
                 if (pDest->CrossRef_D3Dtex != nullptr) {

source/uMod_IDirect3DTexture9.cpp

@@ -1,7 +1,8 @@
 #include "Main.h"
 
-import TextureFunction;
+import ModfileLoader;
 import TextureClient;
+import TextureFunction;
 
 //this function yields for the non switched texture object
 HRESULT APIENTRY uMod_IDirect3DTexture9::QueryInterface(REFIID riid, void** ppvObj)
@@ -203,7 +204,7 @@ HRESULT APIENTRY uMod_IDirect3DTexture9::GetSurfaceLevel(UINT Level, IDirect3DSu
 }
 
 //this function yields for the non switched texture object
-HRESULT APIENTRY uMod_IDirect3DTexture9::LockRect(UINT Level, D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect, DWORD Flags)
+HRESULT APIENTRY uMod_IDirect3DTexture9::LockRect(UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags)
 {
     if (CrossRef_D3Dtex != nullptr) {
         return CrossRef_D3Dtex->m_D3Dtex->LockRect(Level, pLockedRect, pRect, Flags);
@@ -230,7 +231,7 @@ HRESULT APIENTRY uMod_IDirect3DTexture9::AddDirtyRect(CONST RECT* pDirtyRect)
 }
 
 
-HashType uMod_IDirect3DTexture9::GetHash() const
+HashTuple uMod_IDirect3DTexture9::GetHash() const
 {
     ASSERT(!FAKE);
     IDirect3DTexture9* pTexture = m_D3Dtex;
@@ -247,7 +248,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
         Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetLevelDesc \n");
-        return 0;
+        return {};
     }
 
     Message("uMod_IDirect3DTexture9::GetHash() (%d %d) %d\n", desc.Width, desc.Height, desc.Format);
@@ -260,7 +261,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
         IDirect3DSurface9* pSurfaceLevel_orig = nullptr;
         if (pTexture->GetSurfaceLevel(0, &pSurfaceLevel_orig) != D3D_OK) {
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel 1  (D3DPOOL_DEFAULT)\n");
-            return 0;
+            return {};
         }
 
         if (desc.MultiSampleType != D3DMULTISAMPLE_NONE) {
@@ -268,12 +269,12 @@ HashType uMod_IDirect3DTexture9::GetHash() const
             if (D3D_OK != m_D3Ddev->CreateRenderTarget(desc.Width, desc.Height, desc.Format, D3DMULTISAMPLE_NONE, 0, FALSE, &pResolvedSurface, nullptr)) {
                 pSurfaceLevel_orig->Release();
                 Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateRenderTarget  (D3DPOOL_DEFAULT)\n");
-                return 0;
+                return {};
             }
             if (D3D_OK != m_D3Ddev->StretchRect(pSurfaceLevel_orig, nullptr, pResolvedSurface, nullptr, D3DTEXF_NONE)) {
                 pSurfaceLevel_orig->Release();
                 Warning("uMod_IDirect3DTexture9::GetHash() Failed: StretchRect  (D3DPOOL_DEFAULT)\n");
-                return 0;
+                return {};
             }
 
             pSurfaceLevel_orig = pResolvedSurface;
@@ -285,7 +286,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
                 pResolvedSurface->Release();
             }
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateOffscreenPlainSurface (D3DPOOL_DEFAULT)\n");
-            return 0;
+            return {};
         }
 
         if (D3D_OK != m_D3Ddev->GetRenderTargetData(pSurfaceLevel_orig, pOffscreenSurface)) {
@@ -295,7 +296,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
             }
             pOffscreenSurface->Release();
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetRenderTargetData (D3DPOOL_DEFAULT)\n");
-            return 0;
+            return {};
         }
         pSurfaceLevel_orig->Release();
 
@@ -305,24 +306,25 @@ HashType uMod_IDirect3DTexture9::GetHash() const
             }
             pOffscreenSurface->Release();
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect (D3DPOOL_DEFAULT)\n");
-            return 0;
+            return {};
         }
     }
     else if (pTexture->LockRect(0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
         Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetSurfaceLevel(0, &pResolvedSurface) != D3D_OK) {
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel\n");
-            return 0;
+            return {};
         }
         if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
             Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 2\n");
-            return 0;
+            return {};
         }
     }
 
     const int size = (TextureFunction::GetBitsFromFormat(desc.Format) * desc.Width * desc.Height) / 8;
-    const auto hash = TextureFunction::GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    const auto crc32 = TextureFunction::get_crc32(static_cast<char*>(d3dlr.pBits), size);
+    const auto crc64 = HashCheck::Use64BitCrc() ? TextureFunction::get_crc64(static_cast<char*>(d3dlr.pBits), size) : 0;
 
     // Only release surfaces after we're finished with d3dlr
     if (pOffscreenSurface != nullptr) {
@@ -339,6 +341,8 @@ HashType uMod_IDirect3DTexture9::GetHash() const
     else {
         pTexture->UnlockRect(0);
     }
-    Message("uMod_IDirect3DTexture9::GetHash() %#lX (%d %d) %d = %d\n", hash, desc.Width, desc.Height, desc.Format, size);
-    return hash;
+
+    Message("uMod_IDirect3DTexture9::GetHash() crc32 %#lX (%d %d) %d = %d\n", crc32, desc.Width, desc.Height, desc.Format, size);
+    Message("uMod_IDirect3DTexture9::GetHash() crc64 %#llX (%d %d) %d = %d\n", crc64, desc.Width, desc.Height, desc.Format, size);
+    return {crc32, crc64};
 }

source/uMod_IDirect3DVolumeTexture9.cpp

@@ -1,6 +1,8 @@
 #include "Main.h"
-import TextureFunction;
+
+import ModfileLoader;
 import TextureClient;
+import TextureFunction;
 
 HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::QueryInterface(REFIID riid, void** ppvObj)
 {
@@ -225,10 +227,10 @@ HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::UnlockBox(UINT Level)
     return m_D3Dtex->UnlockBox(Level);
 }
 
-HashType uMod_IDirect3DVolumeTexture9::GetHash() const
+HashTuple uMod_IDirect3DVolumeTexture9::GetHash() const
 {
     if (FAKE) {
-        return 0;
+        return {};
     }
     IDirect3DVolumeTexture9* pTexture = m_D3Dtex;
     if (CrossRef_D3Dtex != nullptr) {
@@ -242,7 +244,7 @@ HashType uMod_IDirect3DVolumeTexture9::GetHash() const
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
         Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetLevelDesc \n");
-        return 0;
+        return {};
     }
 
     Message("uMod_IDirect3DVolumeTexture9::GetHash() (%d %d %d) %d\n", desc.Width, desc.Height, desc.Depth, desc.Format);
@@ -250,17 +252,18 @@ HashType uMod_IDirect3DVolumeTexture9::GetHash() const
         Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetVolumeLevel(0, &pResolvedSurface) != D3D_OK) {
             Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetSurfaceLevel\n");
-            return 0;
+            return {};
         }
         if (pResolvedSurface->LockBox(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
             Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 2\n");
-            return 0;
+            return {};
         }
     }
 
     const int size = (TextureFunction::GetBitsFromFormat(desc.Format) * desc.Width * desc.Height * desc.Depth) / 8;
-    const auto hash = TextureFunction::GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    const auto crc32 = TextureFunction::get_crc32(static_cast<char*>(d3dlr.pBits), size);
+    const auto crc64 = HashCheck::Use64BitCrc() ? TextureFunction::get_crc64(static_cast<char*>(d3dlr.pBits), size) : 0;
 
     // Only release surfaces after we're finished with d3dlr
     if (pResolvedSurface != nullptr) {
@@ -271,6 +274,7 @@ HashType uMod_IDirect3DVolumeTexture9::GetHash() const
         pTexture->UnlockBox(0);
     }
 
-    Message("uMod_IDirect3DVolumeTexture9::GetHash() %#lX (%d %d) %d = %d\n", hash, desc.Width, desc.Height, desc.Format, size);
-    return hash;
+    Message("uMod_IDirect3DVolumeTexture9::GetHash() crc32 %#lX (%d %d) %d = %d\n", crc32, desc.Width, desc.Height, desc.Format, size);
+    Message("uMod_IDirect3DVolumeTexture9::GetHash() crc64 %#llX (%d %d) %d = %d\n", crc64, desc.Width, desc.Height, desc.Format, size);
+    return {crc32, crc64};
 }

triplets/x86-windows-mixed.cmake

@@ -0,0 +1,9 @@
+set(VCPKG_TARGET_ARCHITECTURE x86)
+
+if(PORT MATCHES "dxsdk-d3dx")
+    set(VCPKG_CRT_LINKAGE dynamic)
+    set(VCPKG_LIBRARY_LINKAGE dynamic)
+else()
+    set(VCPKG_CRT_LINKAGE static)
+    set(VCPKG_LIBRARY_LINKAGE static)
+endif()

vcpkg-configuration.json

@@ -0,0 +1,14 @@
+{
+  "default-registry": {
+    "kind": "git",
+    "baseline": "7f9f0e44db287e8e67c0e888141bfa200ab45121",
+    "repository": "https://github.com/microsoft/vcpkg"
+  },
+  "registries": [
+    {
+      "kind": "artifact",
+      "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip",
+      "name": "microsoft"
+    }
+  ]
+}

vcpkg.json

@@ -0,0 +1,13 @@
+{
+  "dependencies": [
+    "dxsdk-d3dx",
+    {
+      "name": "libzippp",
+      "features": [
+        "encryption"
+      ]
+    },
+    "minhook",
+    "ms-gsl"
+  ]
+}