1.6.2 (#22)

* minimum 4 chars max 8 chars after 0x for hash in filename

.github/workflows/cd.yaml

@@ -26,66 +26,14 @@ jobs:
       with:
         fetch-depth: 0
 
-    - name:  Config
-      run:   echo "DXSDK_DIR=DXSDK" >> $GITHUB_ENV
-      shell: bash
-
-    - name: Cache
-      id:   cache
-      uses: actions/cache@v1
-      with:
-        path: DXSDK
-        key:  DXSDK
-
-    - name:  Cache create
-      if:    steps.cache.outputs.cache-hit != 'true'
-      run:   |
-        curl -L https://download.microsoft.com/download/a/e/7/ae743f1f-632b-4809-87a9-aa1bb3458e31/DXSDK_Jun10.exe -o _DX2010_.exe
-        7z x _DX2010_.exe DXSDK/Include
-        7z x _DX2010_.exe DXSDK/Lib/x86
-      shell: bash
-
-    - name: Echo cache
-      run: echo ${{ env.DXSDK_DIR }}
-
-    - name: List dxsdk files
-      run: |
-        cd DXSDK
-        ls
-        cd Include
-        ls
-        cd ../Lib/x86
-        ls
-
-    - name: Copy DirectX headers to project include directory
-      run: Copy-Item -Path "${{ env.DXSDK_DIR }}/Include/*" -Destination header/ -Recurse -Force
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
-      shell: pwsh
-
-    - name: Ensure Lib directory exists and copy DirectX libraries
-      run: |
-        $libDir = "Lib/"
-        if (-Not (Test-Path -Path $libDir)) {
-            New-Item -ItemType Directory -Path $libDir
-        }
-        Copy-Item -Path "${{ env.DXSDK_DIR }}/Lib/x86/*" -Destination $libDir -Recurse -Force
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
-      shell: pwsh
-
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.3.1
 
     - name: Build CMake Files
       run: cmake -S . -B build -A Win32
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
 
     - name: Build binaries
       run: cmake --build build --config Release
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
     
     - name: Retrieve version
       id: set_version

.github/workflows/ci.yaml

@@ -29,64 +29,11 @@ jobs:
       with:
         fetch-depth: 0
 
-    #https://stackoverflow.com/questions/61037714/how-to-install-an-old-version-of-the-direct-x-api-in-github-actions
-    - name:  Config
-      run:   echo "DXSDK_DIR=DXSDK" >> $GITHUB_ENV
-      shell: bash
-
-    - name: Cache
-      id:   cache
-      uses: actions/cache@v1
-      with:
-        path: DXSDK
-        key:  DXSDK
-
-    - name:  Cache create
-      if:    steps.cache.outputs.cache-hit != 'true'
-      run:   |
-        curl -L https://download.microsoft.com/download/a/e/7/ae743f1f-632b-4809-87a9-aa1bb3458e31/DXSDK_Jun10.exe -o _DX2010_.exe
-        7z x _DX2010_.exe DXSDK/Include
-        7z x _DX2010_.exe DXSDK/Lib/x86
-      shell: bash
-
-    - name: Echo cache
-      run: echo ${{ env.DXSDK_DIR }}
-
-    - name: List dxsdk files
-      run: |
-        cd DXSDK
-        ls
-        cd Include
-        ls
-        cd ../Lib/x86
-        ls
-
-    - name: Copy DirectX headers to project include directory
-      run: Copy-Item -Path "${{ env.DXSDK_DIR }}/Include/*" -Destination header/ -Recurse -Force
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
-      shell: pwsh
-
-    - name: Ensure Lib directory exists and copy DirectX libraries
-      run: |
-        $libDir = "Lib/"
-        if (-Not (Test-Path -Path $libDir)) {
-            New-Item -ItemType Directory -Path $libDir
-        }
-        Copy-Item -Path "${{ env.DXSDK_DIR }}/Lib/x86/*" -Destination $libDir -Recurse -Force
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
-      shell: pwsh
-
     - name: Setup MSBuild.exe
       uses: microsoft/setup-msbuild@v1.3.1
 
     - name: Build CMake Files
       run: cmake -S . -B build -A Win32
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}
 
     - name: Build binaries
       run: cmake --build build --config Release
-      env:
-        DXSDK_DIR: ${{ env.DXSDK_DIR }}

CMakeLists.txt

@@ -16,8 +16,8 @@ if(${CLEAN} MATCHES "ON")
 endif()
 
 set(VERSION_MAJOR 1)
-set(VERSION_MINOR 5)
-set(VERSION_PATCH 6)
+set(VERSION_MINOR 6)
+set(VERSION_PATCH 2)
 set(VERSION_TWEAK 0)
 
 set(VERSION_RC "${CMAKE_CURRENT_BINARY_DIR}/version.rc")
@@ -31,36 +31,22 @@ set(CMAKE_INSTALL_PREFIX ${PROJECT_SOURCE_DIR}/bin/install)
 
 add_compile_options(/MP /permissive-)
 
-find_library(D3D9_LIB NAMES d3d9 PATHS $ENV{DXSDK_DIR}/lib/x86 NO_DEFAULT_PATH)
-find_library(D3DX9_LIB NAMES d3dx9 PATHS $ENV{DXSDK_DIR}/lib/x86 NO_DEFAULT_PATH)
-find_library(DXGUID_LIB NAMES dxguid PATHS $ENV{DXSDK_DIR}/lib/x86 NO_DEFAULT_PATH)
-
-if(NOT D3D9_LIB)
-    find_library(D3D9_LIB NAMES d3d9 PATHS ${CMAKE_SOURCE_DIR}/Lib)
-endif()
-
-if(NOT D3DX9_LIB)
-    find_library(D3DX9_LIB NAMES d3dx9 PATHS ${CMAKE_SOURCE_DIR}/Lib)
-endif()
-
-if(NOT DXGUID_LIB)
-    find_library(DXGUID_LIB NAMES dxguid PATHS ${CMAKE_SOURCE_DIR}/Lib)
-endif()
-
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 include(libzippp)
 include(minhook)
+include(dxtk)
+include(msgsl)
 
 add_library(gMod SHARED)
 
 file(GLOB SOURCES
     "header/*.h"
     "source/*.cpp"
+    "modules/*.ixx"
     ${VERSION_RC}
     )
 
-target_include_directories(gMod PRIVATE $ENV{DXSDK_DIR}/Include)
-target_include_directories(gMod PUBLIC
+target_include_directories(gMod PRIVATE
     "header"
     ${CMAKE_INSTALL_PREFIX}/include
     )
@@ -68,15 +54,16 @@ source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${SOURCES})
 target_sources(gMod PRIVATE ${SOURCES})
 
 target_link_libraries(gMod PRIVATE
-    ${D3D9_LIB}
-    ${D3DX9_LIB}
-    ${DXGUID_LIB}
+    dxguid
     libzippp
-	psapi
-	minhook
+    psapi
+    minhook
+    directxtex
+    Microsoft.GSL::GSL
     )
 target_link_options(gMod PRIVATE
     "$<$<CONFIG:DEBUG>:/NODEFAULTLIB:LIBCMT>"
+	"/LARGEADDRESSAWARE"
     )
 source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${SOURCES})
 target_sources(gMod PRIVATE ${SOURCES})

README.md

@@ -0,0 +1,26 @@
+Requirements:
+- Visual Studio 2022
+- CMake 3.16+, integrated into the Developer Powershell for VS 2022
+
+Compile:
+- cmake -B build
+- cmake --open build
+- compile
+
+*Usage is primarily intended with GW Launcher or Daybreak, but it can be used without.*
+
+**Usage with manual gMod.dll injection:**
+- Create a file called modlist.txt in either the Guild Wars (Gw.exe) folder, or the gMod.dll folder.
+- Inject gMod.dll before d3d9.dll is loaded.
+
+**Usage without dll injection:**
+- Create a file called modlist.txt in the Guild Wars (Gw.exe) folder.
+- Place gMod.dll in the Guild Wars folder
+- Rename gMod.dll to d3d9.dll
+- Launch Guild Wars
+
+**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

README.txt

@@ -1,9 +0,0 @@
-Requirements:
-- The DirectX SDK (I use June 2010)
-- Visual Studio (2010+)
-(- Maybe CMake if you don't want to use Visual Studio)
-
-Usage:
-Create a file in the root GuildWars folder (where gw.exe is located) called modlist.txt
-Each line in the modlist.txt is the full path to a mod you want to load (eg. D:Games\uMod\Mods\Borderless Cartography Made Easy 2015 1.3.tpf)
-uMod will load all these files on startup

cmake/dxtk.cmake

@@ -0,0 +1,31 @@
+include_guard()
+include(FetchContent)
+
+FetchContent_Declare(
+    DirectXTex
+    GIT_REPOSITORY https://github.com/microsoft/DirectXTex
+    GIT_TAG oct2023)
+FetchContent_GetProperties(directxtex)
+if (directxtex_POPULATED)
+    return()
+endif()
+
+FetchContent_Populate(directxtex)
+
+add_library(directxtex)
+file(GLOB SOURCES
+    "${directxtex_SOURCE_DIR}/DDSTextureLoader/DDSTextureLoader9.h"
+    "${directxtex_SOURCE_DIR}/DDSTextureLoader/DDSTextureLoader9.cpp"
+    "${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.h"
+    "${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.cpp"
+    "${directxtex_SOURCE_DIR}/DirectXTex/*.h"
+    "${directxtex_SOURCE_DIR}/DirectXTex/*.cpp"
+    )
+list(REMOVE_ITEM SOURCES
+    "${directxtex_SOURCE_DIR}/DirectXTex/BCDirectCompute.cpp"
+	)
+source_group(TREE ${directxtex_SOURCE_DIR} FILES ${SOURCES})
+target_sources(directxtex PRIVATE ${SOURCES})
+target_include_directories(directxtex PUBLIC "${directxtex_SOURCE_DIR}")
+
+set_target_properties(directxtex PROPERTIES FOLDER "Dependencies/")

cmake/msgsl.cmake

@@ -0,0 +1,11 @@
+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)

header/Defines.h

@@ -3,13 +3,48 @@
 //#define HashType DWORD64
 using HashType = DWORD32;
 
-#ifdef LOG_MESSAGE
-#include <iostream>
+struct TexEntry {
+    std::vector<BYTE> data{};
+    HashType crc_hash = 0; // hash value
+    std::string ext{};
+};
 
+struct TextureFileStruct {
+    std::vector<BYTE> data{};
+    HashType crc_hash = 0; // hash value
+};
+
+inline void Message(const char* format, ...)
+{
 #ifdef _DEBUG
-#define Message(...) { printf(__VA_ARGS__); }
-#else
-#define Message(...)
+#if 0
+    va_list args;
+    va_start(args, format);
+    vprintf(format, args);
+    va_end(args);
 #endif
+#endif
+}
 
+inline void Info(const char* format, ...)
+{
+#ifdef _DEBUG
+    va_list args;
+    va_start(args, format);
+    vprintf(format, args);
+    va_end(args);
 #endif
+}
+
+inline void Warning(const char* format, ...)
+{
+#ifdef _DEBUG
+    static HANDLE hConsole = GetStdHandle(STD_ERROR_HANDLE);
+    [[maybe_unused]] static auto success = SetConsoleTextAttribute(hConsole, 6);
+    va_list args;
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+#endif
+}
+

header/FileLoader.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <string>
-#include <ranges>
-#include <libzippp.h>
-
-struct TpfEntry {
-    std::string name;
-    std::string entry;
-    uint32_t crc_hash;
-    std::vector<char> data;
-};
-
-class FileLoader {
-    std::string 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:
-    FileLoader(const std::string& fileName);
-
-    std::vector<TpfEntry> GetContents();
-
-private:
-
-    std::vector<TpfEntry> GetTpfContents();
-
-    std::vector<TpfEntry> GetFileContents();
-
-    void LoadEntries(libzippp::ZipArchive& archive, std::vector<TpfEntry>& entries);
-};

header/Main.h

@@ -4,16 +4,19 @@
 
 #include <cstdlib>
 #include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <future>
+#include <map>
+#include <ranges>
 #include "Utils.h"
 
 #include <d3d9.h>
-#include <d3dx9.h>
+#include <gsl/gsl>
 
 #include "Defines.h"
 #include "Error.h"
 #include "Defines.h"
-#include "dll_main.h"
-#include "TextureFunction.h"
 
 #include "uMod_IDirect3D9.h"
 #include "uMod_IDirect3D9Ex.h"
@@ -25,8 +28,6 @@
 #include "uMod_IDirect3DTexture9.h"
 #include "uMod_IDirect3DVolumeTexture9.h"
 
-#include "TextureClient.h"
-
 #pragma warning(disable : 4477)
 
 extern unsigned int gl_ErrorState;

header/TextureClient.h

@@ -1,251 +0,0 @@
-#pragma once
-
-#include <map>
-
-#include "FileLoader.h"
-#include "uMod_IDirect3DTexture9.h"
-
-extern unsigned int gl_ErrorState;
-
-struct TextureFileStruct {
-    std::vector<char> data{};
-    HashType crc_hash = 0; // hash value
-};
-
-template <typename T>
-concept uModTexturePtr = requires(T a)
-{
-    std::same_as<uMod_IDirect3DTexture9*, T> ||
-    std::same_as<uMod_IDirect3DVolumeTexture9*, T> ||
-    std::same_as<uMod_IDirect3DCubeTexture9*, T>;
-};
-
-template <typename T>
-concept uModTexturePtrPtr = uModTexturePtr<std::remove_pointer_t<T>>;
-
-/*
- *  An object of this class is owned by each d3d9 device.
- *  functions called by the Server are called from the server thread instance.
- *  All other functions are called from the render thread instance of the game itself.
- */
-class TextureClient {
-public:
-    TextureClient(IDirect3DDevice9* device);
-    ~TextureClient();
-
-    int AddTexture(uModTexturePtr auto pTexture);
-    int RemoveTexture(uModTexturePtr auto pTexture); //called from  uMod_IDirect3DTexture9::Release()
-    int LookUpToMod(uModTexturePtr auto pTexture);
-    // called at the end AddTexture(...) and from Device->UpdateTexture(...)
-
-    int MergeUpdate(); //called from uMod_IDirect3DDevice9::BeginScene()
-
-    // Add TpfEntry data, return size of data added. 0 on failure.
-    unsigned long AddFile(TpfEntry& entry);
-
-    std::vector<uMod_IDirect3DTexture9*> OriginalTextures;
-    // stores the pointer to the uMod_IDirect3DTexture9 objects created by the game
-    std::vector<uMod_IDirect3DVolumeTexture9*> OriginalVolumeTextures;
-    // stores the pointer to the uMod_IDirect3DVolumeTexture9 objects created by the game
-    std::vector<uMod_IDirect3DCubeTexture9*> OriginalCubeTextures;
-    // stores the pointer to the uMod_IDirect3DCubeTexture9 objects created by the game
-
-    D3DCOLOR FontColour;
-    D3DCOLOR TextureColour;
-
-    void Initialize();
-
-private:
-    IDirect3DDevice9* D3D9Device;
-    // Cached info about whether this id a dx9ex device or not; used for proxy functions
-    bool isDirectXExDevice = false;
-
-    // DX9 proxy functions
-    uMod_IDirect3DTexture9* GetSingleTexture();
-    uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture();
-    uMod_IDirect3DCubeTexture9* GetSingleCubeTexture();
-    int SetLastCreatedTexture(uMod_IDirect3DTexture9*);
-    int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9*);
-    int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9*);
-
-    bool should_update = false;
-
-    int LockMutex();
-    int UnlockMutex();
-    HANDLE Mutex;
-
-    std::unordered_map<HashType, TextureFileStruct*> modded_textures;
-    // array which stores the file in memory and the hash of each texture to be modded
-
-    // called if a target texture is found
-    int LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtrPtr auto ppTexture);
-
-    void LoadModsFromFile(const char* source);
-};
-
-int TextureClient::AddTexture(uModTexturePtr auto pTexture)
-{
-    if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
-        SetLastCreatedTexture(nullptr);
-    }
-    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
-        SetLastCreatedVolumeTexture(nullptr);
-    }
-    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
-        SetLastCreatedCubeTexture(nullptr);
-    }
-
-    if (pTexture->FAKE) {
-        return RETURN_OK; // this is a fake texture
-    }
-
-    if (gl_ErrorState & uMod_ERROR_FATAL) {
-        return RETURN_FATAL_ERROR;
-    }
-
-    Message("TextureClient::AddTexture( Cube: %p): %p (thread: %u)\n", pTexture, this, GetCurrentThreadId());
-
-    pTexture->Hash = pTexture->GetHash();
-    if (!pTexture->Hash) {
-        return RETURN_FATAL_ERROR;
-    }
-
-    if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
-        OriginalTextures.push_back(pTexture);
-    }
-    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
-        OriginalVolumeTextures.push_back(pTexture);
-    }
-    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
-        OriginalCubeTextures.push_back(pTexture);
-    }
-
-    return LookUpToMod(pTexture); // check if this texture should be modded
-}
-
-int TextureClient::RemoveTexture(uModTexturePtr auto pTexture)
-{
-    Message("TextureClient::RemoveTexture( %p, %#lX): %p\n", pTexture, pTexture->Hash, this);
-
-    if (gl_ErrorState & uMod_ERROR_FATAL) {
-        return RETURN_FATAL_ERROR;
-    }
-
-    if (!pTexture->FAKE) {
-        if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
-            utils::erase_first(OriginalTextures, pTexture);
-        }
-        else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
-            utils::erase_first(OriginalVolumeTextures, pTexture);
-        }
-        else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
-            utils::erase_first(OriginalCubeTextures, pTexture);
-        }
-    }
-    if (!pTexture->Reference)
-        return RETURN_OK; // Should this ever happen?
-    return RETURN_OK;
-}
-
-int TextureClient::LookUpToMod(uModTexturePtr auto pTexture)
-{
-    Message("TextureClient::LookUpToMod( %p): hash: %#lX,  %p\n", pTexture, pTexture->Hash, this);
-    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);
-    if (found == modded_textures.end())
-        return ret;
-
-    const auto textureFileStruct = found->second;
-
-    decltype(pTexture) fake_Texture;
-    ret = LoadTexture(textureFileStruct, &fake_Texture);
-    if (ret != RETURN_OK)
-        return ret;
-
-    ret = SwitchTextures(fake_Texture, pTexture);
-    if (ret != RETURN_OK) {
-        Message("TextureClient::LookUpToMod(): textures not switched %#lX\n", textureFileStruct->crc_hash);
-        fake_Texture->Release();
-        return ret;
-    }
-    fake_Texture->Reference = textureFileStruct;
-    return ret;
-}
-
-int TextureClient::LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtrPtr auto ppTexture)
-{
-    Message("LoadTexture( %p, %p, %#lX): %p\n", file_in_memory, ppTexture, file_in_memory->crc_hash, this);
-    if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DTexture9**>) {
-        if (D3D_OK != D3DXCreateTextureFromFileInMemoryEx(
-                D3D9Device, file_in_memory->data.data(),
-                file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT,
-                D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
-                D3DX_DEFAULT, D3DX_DEFAULT, 0, nullptr, nullptr,
-                (IDirect3DTexture9**)ppTexture)) {
-            *ppTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        SetLastCreatedTexture(nullptr);
-    }
-    else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DVolumeTexture9**>) {
-        if (D3D_OK != D3DXCreateVolumeTextureFromFileInMemoryEx(
-                D3D9Device, file_in_memory->data.data(),
-                file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT,
-                D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
-                D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0,
-                nullptr,
-                nullptr,
-                (IDirect3DVolumeTexture9**)ppTexture)) {
-            *ppTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        SetLastCreatedVolumeTexture(nullptr);
-    }
-    else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DCubeTexture9**>) {
-        if (D3D_OK != D3DXCreateCubeTextureFromFileInMemoryEx(
-                D3D9Device, file_in_memory->data.data(), file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT, 0,
-                D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
-                D3DX_DEFAULT, D3DX_DEFAULT, 0, nullptr, nullptr,
-                (IDirect3DCubeTexture9**)ppTexture)) {
-            *ppTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        SetLastCreatedCubeTexture(nullptr);
-    }
-    (*ppTexture)->FAKE = true;
-
-    Message("LoadTexture( %p, %#lX): DONE\n", *ppTexture, file_in_memory->crc_hash);
-    return RETURN_OK;
-}
-
-template<typename T> requires uModTexturePtr<T>
-void UnswitchTextures(T pTexture)
-{
-    decltype(pTexture) CrossRef = pTexture->CrossRef_D3Dtex;
-    if (CrossRef != nullptr) {
-        std::swap(pTexture->m_D3Dtex, CrossRef->m_D3Dtex);
-
-        // cancel the link
-        CrossRef->CrossRef_D3Dtex = nullptr;
-        pTexture->CrossRef_D3Dtex = nullptr;
-    }
-}
-
-template<typename T> requires uModTexturePtr<T>
-inline int SwitchTextures(T pTexture1, T pTexture2)
-{
-    if (pTexture1->m_D3Ddev == pTexture2->m_D3Ddev && pTexture1->CrossRef_D3Dtex == nullptr && pTexture2->CrossRef_D3Dtex == nullptr) {
-        // make cross reference
-        pTexture1->CrossRef_D3Dtex = pTexture2;
-        pTexture2->CrossRef_D3Dtex = pTexture1;
-
-        // switch textures
-        std::swap(pTexture1->m_D3Dtex, pTexture2->m_D3Dtex);
-        return RETURN_OK;
-    }
-    return RETURN_TEXTURE_NOT_SWITCHED;
-}

header/TextureFunction.h

@@ -1,138 +0,0 @@
-#pragma once
-
-constexpr auto crc32_poly = 0xEDB88320u;
-constexpr auto ul_crc_in = 0xffffffff;
-
-inline unsigned int GetCRC32(char* pcDatabuf, unsigned int ulDatalen)
-{
-    unsigned int crc = ul_crc_in;
-    for (unsigned int idx = 0u; idx < ulDatalen; idx++) {
-        unsigned int data = *pcDatabuf++;
-        for (unsigned int bit = 0u; bit < 8u; bit++, data >>= 1) {
-            crc = crc >> 1 ^ ((crc ^ data) & 1 ? crc32_poly : 0);
-        }
-    }
-    return crc;
-}
-
-/*
-    case D3DFMT_MULTI2_ARGB8:
-    case D3DFMT_VERTEXDATA:
-    */
-inline int GetBitsFromFormat(D3DFORMAT format)
-{
-    switch (format) //switch trough the formats to calculate the size of the raw data
-    {
-        case D3DFMT_A1: // 1-bit monochrome.
-        {
-            return 1;
-            break;
-        }
-
-        case D3DFMT_R3G3B2: // 8-bit RGB texture format using 3 bits for red, 3 bits for green, and 2 bits for blue.
-        case D3DFMT_A8: // 8-bit alpha only.
-        case D3DFMT_A8P8: // 8-bit color indexed with 8 bits of alpha.
-        case D3DFMT_P8: // 8-bit color indexed.
-        case D3DFMT_L8: // 8-bit luminance only.
-        case D3DFMT_A4L4: // 8-bit using 4 bits each for alpha and luminance.
-        case D3DFMT_FORCE_DWORD:
-        case D3DFMT_S8_LOCKABLE: // A lockable 8-bit stencil buffer.
-        {
-            return 8;
-            break;
-        }
-
-        case D3DFMT_D16_LOCKABLE: //16-bit z-buffer bit depth.
-        case D3DFMT_D15S1: // 16-bit z-buffer bit depth where 15 bits are reserved for the depth channel and 1 bit is reserved for the stencil channel.
-        case D3DFMT_L6V5U5: // 16-bit bump-map format with luminance using 6 bits for luminance, and 5 bits each for v and u.
-        case D3DFMT_V8U8: // 16-bit bump-map format using 8 bits each for u and v data.
-        case D3DFMT_CxV8U8: // 16-bit normal compression format. The texture sampler computes the C channel from: C = sqrt(1 - U2 - V2).
-        case D3DFMT_R5G6B5: // 16-bit RGB pixel format with 5 bits for red, 6 bits for green, and 5 bits for blue.
-        case D3DFMT_X1R5G5B5: // 16-bit pixel format where 5 bits are reserved for each color.
-        case D3DFMT_A1R5G5B5: // 16-bit pixel format where 5 bits are reserved for each color and 1 bit is reserved for alpha.
-        case D3DFMT_A4R4G4B4: // 16-bit ARGB pixel format with 4 bits for each channel.
-        case D3DFMT_A8R3G3B2: // 16-bit ARGB texture format using 8 bits for alpha, 3 bits each for red and green, and 2 bits for blue.
-        case D3DFMT_X4R4G4B4: // 16-bit RGB pixel format using 4 bits for each color.
-        case D3DFMT_L16: // 16-bit luminance only.
-        case D3DFMT_R16F: // 16-bit float format using 16 bits for the red channel.
-        case D3DFMT_A8L8: // 16-bit using 8 bits each for alpha and luminance.
-        case D3DFMT_D16: // 16-bit z-buffer bit depth.
-        case D3DFMT_INDEX16: // 16-bit index buffer bit depth.
-        case D3DFMT_G8R8_G8B8: // ??
-        case D3DFMT_R8G8_B8G8: // ??
-        case D3DFMT_UYVY: // ??
-        case D3DFMT_YUY2: // ??
-        {
-            return 16;
-            break;
-        }
-
-
-        case D3DFMT_R8G8B8: //24-bit RGB pixel format with 8 bits per channel.
-        {
-            return 24;
-            break;
-        }
-
-        case D3DFMT_R32F: // 32-bit float format using 32 bits for the red channel.
-        case D3DFMT_X8L8V8U8: // 32-bit bump-map format with luminance using 8 bits for each channel.
-        case D3DFMT_A2W10V10U10: // 32-bit bump-map format using 2 bits for alpha and 10 bits each for w, v, and u.
-        case D3DFMT_Q8W8V8U8: // 32-bit bump-map format using 8 bits for each channel.
-        case D3DFMT_V16U16: // 32-bit bump-map format using 16 bits for each channel.
-        case D3DFMT_A8R8G8B8: // 32-bit ARGB pixel format with alpha, using 8 bits per channel.
-        case D3DFMT_X8R8G8B8: // 32-bit RGB pixel format, where 8 bits are reserved for each color.
-        case D3DFMT_A2B10G10R10: // 32-bit pixel format using 10 bits for each color and 2 bits for alpha.
-        case D3DFMT_A8B8G8R8: // 32-bit ARGB pixel format with alpha, using 8 bits per channel.
-        case D3DFMT_X8B8G8R8: // 32-bit RGB pixel format, where 8 bits are reserved for each color.
-        case D3DFMT_G16R16: // 32-bit pixel format using 16 bits each for green and red.
-        case D3DFMT_G16R16F: // 32-bit float format using 16 bits for the red channel and 16 bits for the green channel.
-        case D3DFMT_A2R10G10B10: // 32-bit pixel format using 10 bits each for red, green, and blue, and 2 bits for alpha.
-        case D3DFMT_D32: // 32-bit z-buffer bit depth.
-        case D3DFMT_D24S8: // 32-bit z-buffer bit depth using 24 bits for the depth channel and 8 bits for the stencil channel.
-        case D3DFMT_D24X8: //32-bit z-buffer bit depth using 24 bits for the depth channel.
-        case D3DFMT_D24X4S4: // 32-bit z-buffer bit depth using 24 bits for the depth channel and 4 bits for the stencil channel.
-        case D3DFMT_D32F_LOCKABLE: // A lockable format where the depth value is represented as a standard IEEE floating-point number.
-        case D3DFMT_D24FS8: // A non-lockable format that contains 24 bits of depth (in a 24-bit floating point format - 20e4) and 8 bits of stencil.
-        case D3DFMT_D32_LOCKABLE: // A lockable 32-bit depth buffer.
-        case D3DFMT_INDEX32: // 32-bit index buffer bit depth.
-            //case : //
-            //case : //
-            //case : //
-            //case : //
-        {
-            return 32;
-            break;
-        }
-
-        case D3DFMT_G32R32F: // 64-bit float format using 32 bits for the red channel and 32 bits for the green channel.
-        case D3DFMT_Q16W16V16U16: // 64-bit bump-map format using 16 bits for each component.
-        case D3DFMT_A16B16G16R16: // 64-bit pixel format using 16 bits for each component.
-        case D3DFMT_A16B16G16R16F: // 64-bit float format using 16 bits for the each channel (alpha, blue, green, red).
-        {
-            return 64;
-            break;
-        }
-
-        case D3DFMT_A32B32G32R32F: // 128-bit float format using 32 bits for the each channel (alpha, blue, green, red).
-        {
-            return 128;
-            break;
-        }
-        case D3DFMT_DXT2:
-        case D3DFMT_DXT3:
-        case D3DFMT_DXT4:
-        case D3DFMT_DXT5: {
-            return 8;
-            break;
-        }
-        case D3DFMT_DXT1: {
-            return 4;
-            break;
-        }
-        default: //compressed formats
-        {
-            return 4;
-            break;
-        }
-    }
-}

header/dll_main.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <d3d9.h>
-
-void InitInstance(HINSTANCE hModule);
-void ExitInstance();
-HMODULE LoadOriginalDll();
-
-IDirect3D9* APIENTRY uMod_Direct3DCreate9(UINT SDKVersion);
-HRESULT APIENTRY uMod_Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex** ppD3D);

header/uMod_IDirect3DDevice9.h

@@ -1,12 +1,11 @@
 #pragma once
 
 #include <d3d9.h>
-#include <d3dx9.h>
 #include "uMod_IDirect3DTexture9.h"
 #include "uMod_IDirect3DVolumeTexture9.h"
 #include "uMod_IDirect3DCubeTexture9.h"
-#include "TextureClient.h"
 
+class TextureClient;
 
 class uMod_IDirect3DDevice9 : public IDirect3DDevice9 {
 public:
@@ -140,50 +139,31 @@ public:
 
     uMod_IDirect3DTexture9* GetLastCreatedTexture() { return LastCreatedTexture; }
 
-    int SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
+    void SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
     {
         LastCreatedTexture = pTexture;
-        return RETURN_OK;
     }
 
     uMod_IDirect3DVolumeTexture9* GetLastCreatedVolumeTexture() { return LastCreatedVolumeTexture; }
 
-    int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
+    void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
     {
         LastCreatedVolumeTexture = pTexture;
-        return RETURN_OK;
     }
 
     uMod_IDirect3DCubeTexture9* GetLastCreatedCubeTexture() { return LastCreatedCubeTexture; }
 
-    int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
+    void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
     {
         LastCreatedCubeTexture = pTexture;
-        return RETURN_OK;
     }
 
-
-    uMod_IDirect3DTexture9* GetSingleTexture() { return SingleTexture; }
-    uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture() { return SingleVolumeTexture; }
-    uMod_IDirect3DCubeTexture9* GetSingleCubeTexture() { return SingleCubeTexture; }
-
 private:
-    int CreateSingleTexture();
     IDirect3DDevice9* m_pIDirect3DDevice9 = nullptr;
 
-    int CounterSaveSingleTexture;
-    uMod_IDirect3DTexture9* SingleTexture = nullptr;
-    uMod_IDirect3DVolumeTexture9* SingleVolumeTexture = nullptr;
-    uMod_IDirect3DCubeTexture9* SingleCubeTexture = nullptr;
-    char SingleTextureMod;
-
-    D3DCOLOR TextureColour;
-    ID3DXFont* OSD_Font;
-    //D3DCOLOR FontColour;
     int BackBufferCount;
-    bool NormalRendering;
-
-    int uMod_Reference;
+    bool NormalRendering = true;
+    int uMod_Reference = 1;
 
     uMod_IDirect3DTexture9* LastCreatedTexture = nullptr;
     uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture = nullptr;

header/uMod_IDirect3DDevice9Ex.h

@@ -1,12 +1,11 @@
 #pragma once
 
 #include <d3d9.h>
-#include <d3dx9.h>
 #include "uMod_IDirect3DTexture9.h"
 #include "uMod_IDirect3DVolumeTexture9.h"
 #include "uMod_IDirect3DCubeTexture9.h"
-#include "TextureClient.h"
 
+class TextureClient;
 
 class uMod_IDirect3DDevice9Ex : public IDirect3DDevice9Ex {
 public:
@@ -162,54 +161,36 @@ public:
 
     uMod_IDirect3DTexture9* GetLastCreatedTexture() { return LastCreatedTexture; }
 
-    int SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
+    void SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
     {
         LastCreatedTexture = pTexture;
-        return RETURN_OK;
     }
 
     uMod_IDirect3DVolumeTexture9* GetLastCreatedVolumeTexture() { return LastCreatedVolumeTexture; }
 
-    int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
+    void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
     {
         LastCreatedVolumeTexture = pTexture;
-        return RETURN_OK;
     }
 
     uMod_IDirect3DCubeTexture9* GetLastCreatedCubeTexture() { return LastCreatedCubeTexture; }
 
-    int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
+    void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
     {
         LastCreatedCubeTexture = pTexture;
-        return RETURN_OK;
     }
 
-
-    uMod_IDirect3DTexture9* GetSingleTexture() { return SingleTexture; }
-    uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture() { return SingleVolumeTexture; }
-    uMod_IDirect3DCubeTexture9* GetSingleCubeTexture() { return SingleCubeTexture; }
-
 private:
-    int CreateSingleTexture();
     IDirect3DDevice9Ex* m_pIDirect3DDevice9Ex;
 
-    int CounterSaveSingleTexture;
-    uMod_IDirect3DTexture9* SingleTexture;
-    uMod_IDirect3DVolumeTexture9* SingleVolumeTexture;
-    uMod_IDirect3DCubeTexture9* SingleCubeTexture;
-    char SingleTextureMod;
-
-    D3DCOLOR TextureColour;
-    ID3DXFont* OSD_Font;
-    //D3DCOLOR FontColour;
     int BackBufferCount;
-    bool NormalRendering;
+    bool NormalRendering = true;
 
-    int uMod_Reference;
+    int uMod_Reference = 1;
 
-    uMod_IDirect3DTexture9* LastCreatedTexture;
-    uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture;
-    uMod_IDirect3DCubeTexture9* LastCreatedCubeTexture;
+    uMod_IDirect3DTexture9* LastCreatedTexture = nullptr;
+    uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture = nullptr;
+    uMod_IDirect3DCubeTexture9* LastCreatedCubeTexture = nullptr;
 
-    TextureClient* uMod_Client;
+    TextureClient* uMod_Client = nullptr;
 };

header/uMod_IDirect3DTexture9.h

@@ -7,11 +7,14 @@ interface uMod_IDirect3DTexture9 : public IDirect3DTexture9 {
     {
         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_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()
+    {
+
+    }
 
     // callback interface
     IDirect3DTexture9* m_D3Dtex = nullptr;

modules/ModfileLoader.ixx

@@ -0,0 +1,186 @@
+module;
+
+#include "Main.h"
+#include "Defines.h"
+
+export module ModfileLoader;
+
+import <intsafe.h>;
+import <vector>;
+import <string>;
+import <libzippp.h>;
+import <regex>;
+import <algorithm>;
+import <filesystem>;
+import ModfileLoader.TpfReader;
+
+export class ModfileLoader {
+    std::string 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::string& fileName);
+
+    std::vector<TexEntry> GetContents();
+
+private:
+
+    std::vector<TexEntry> GetTpfContents();
+
+    std::vector<TexEntry> GetFileContents();
+
+    void LoadEntries(libzippp::ZipArchive& archive, std::vector<TexEntry>& entries);
+};
+
+ModfileLoader::ModfileLoader(const std::string& fileName)
+{
+    file_name = std::filesystem::absolute(fileName).string();
+}
+
+std::vector<TexEntry> ModfileLoader::GetContents()
+{
+    try {
+        return file_name.ends_with(".tpf") ? GetTpfContents() : GetFileContents();
+    }
+    catch (const std::exception&) {
+        Warning("Failed to open mod file: %s\n", file_name.c_str());
+    }
+    return {};
+}
+
+std::vector<TexEntry> ModfileLoader::GetTpfContents()
+{
+    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) {
+        Warning("Failed to open tpf file: %s - %u bytes!", file_name.c_str(), buffer.size());
+        return {};
+    }
+    zip_archive->setErrorHandlerCallback(
+        [](const std::string& message, const std::string& strerror, int zip_error_code, int system_error_code) -> void {
+            Message("GetTpfContents: %s %s %d %d\n", message.c_str(), strerror.c_str(), 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()
+{
+    std::vector<TexEntry> entries;
+
+    libzippp::ZipArchive zip_archive(file_name);
+    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()) {
+            //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;
+        }
+    }
+}
+
+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;
+        std::regex_search(line, match, address_file_regex);
+        if (match.size() != 3u)
+            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()) {
+            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());
+            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());
+        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);
+    }
+}

modules/ModfileLoader_TpfReader.ixx

@@ -1,9 +1,10 @@
-#pragma once
+export module ModfileLoader.TpfReader;
 
-#include <fstream>
-#include <vector>
+import <string>;
+import <fstream>;
+import <vector>;
 
-class TpfReader {
+export class TpfReader {
 public:
     TpfReader(const std::string& path)
     {

modules/TextureClient.ixx

@@ -0,0 +1,386 @@
+module;
+
+#include "Main.h"
+#include "Error.h"
+#include "uMod_IDirect3DTexture9.h"
+#include <DDSTextureLoader/DDSTextureLoader9.h>
+#include <DirectXTex/DirectXTex.h>
+
+export module TextureClient;
+import TextureFunction;
+import ModfileLoader;
+
+/*
+ *  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.
+ */
+export class TextureClient {
+public:
+    TextureClient(IDirect3DDevice9* device);
+    ~TextureClient();
+
+    int AddTexture(uModTexturePtr auto pTexture);
+    int RemoveTexture(uModTexturePtr auto pTexture); //called from  uMod_IDirect3DTexture9::Release()
+    int LookUpToMod(uModTexturePtr auto pTexture);
+    // called at the end AddTexture(...) and from Device->UpdateTexture(...)
+
+    int MergeUpdate(); //called from uMod_IDirect3DDevice9::BeginScene()
+    void Initialize();
+
+    std::vector<uMod_IDirect3DTexture9*> OriginalTextures;
+    // stores the pointer to the uMod_IDirect3DTexture9 objects created by the game
+    std::vector<uMod_IDirect3DVolumeTexture9*> OriginalVolumeTextures;
+    // stores the pointer to the uMod_IDirect3DVolumeTexture9 objects created by the game
+    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
+    bool isDirectXExDevice = false;
+
+    // DX9 proxy functions
+    void SetLastCreatedTexture(uMod_IDirect3DTexture9*);
+    void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9*);
+    void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9*);
+
+    bool should_update = false;
+
+    int LockMutex();
+    int UnlockMutex();
+    HANDLE hMutex;
+
+    std::unordered_map<HashType, gsl::owner<TextureFileStruct*>> modded_textures;
+    // array which stores the file in memory and the hash of each texture to be modded
+
+    // 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
+    std::filesystem::path dll_path; // path to gmod dll
+};
+
+TextureClient::TextureClient(IDirect3DDevice9* device)
+{
+    Message("TextureClient::TextureClient(): %p\n", this);
+    D3D9Device = device;
+
+    void* cpy;
+    isDirectXExDevice = D3D9Device->QueryInterface(IID_IDirect3DTexture9, &cpy) == 0x01000001L;
+
+    hMutex = CreateMutex(nullptr, false, nullptr);
+}
+
+TextureClient::~TextureClient()
+{
+    Message("TextureClient::~TextureClient(): %p\n", this);
+    if (hMutex != nullptr) {
+        CloseHandle(hMutex);
+    }
+    for (const auto texture_file_struct : modded_textures | std::views::values) {
+        delete texture_file_struct;
+    }
+    modded_textures.clear();
+}
+
+int TextureClient::MergeUpdate()
+{
+    if (!should_update) return RETURN_OK;
+    should_update = false;
+    if (const int ret = LockMutex()) {
+        gl_ErrorState |= uMod_ERROR_TEXTURE;
+        return ret;
+    }
+
+    Message("MergeUpdate(): %p\n", this);
+
+    for (const auto pTexture : OriginalTextures) {
+        if (pTexture->CrossRef_D3Dtex == nullptr) {
+            LookUpToMod(pTexture);
+        }
+    }
+    for (const auto pTexture : OriginalVolumeTextures) {
+        if (pTexture->CrossRef_D3Dtex == nullptr) {
+            LookUpToMod(pTexture);
+        }
+    }
+    for (const auto pTexture : OriginalCubeTextures) {
+        if (pTexture->CrossRef_D3Dtex == nullptr) {
+            LookUpToMod(pTexture);
+        }
+    }
+
+    return UnlockMutex();
+}
+
+void TextureClient::SetLastCreatedTexture(uMod_IDirect3DTexture9* texture)
+{
+    if (isDirectXExDevice)
+        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedTexture(texture);
+    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedTexture(texture);
+}
+
+void TextureClient::SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* texture)
+{
+    if (isDirectXExDevice)
+        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
+    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
+}
+
+void TextureClient::SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* texture)
+{
+    if (isDirectXExDevice)
+        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
+    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
+}
+
+int TextureClient::LockMutex()
+{
+    if ((gl_ErrorState & (uMod_ERROR_FATAL | uMod_ERROR_MUTEX))) {
+        return RETURN_NO_MUTEX;
+    }
+    if (WAIT_OBJECT_0 != WaitForSingleObject(hMutex, 100)) {
+        return RETURN_MUTEX_LOCK; //waiting 100ms, to wait infinite pass INFINITE
+    }
+    return RETURN_OK;
+}
+
+int TextureClient::UnlockMutex()
+{
+    if (ReleaseMutex(hMutex) == 0) {
+        return RETURN_MUTEX_UNLOCK;
+    }
+    return RETURN_OK;
+}
+
+gsl::owner<TextureFileStruct*> AddFile(TexEntry& entry, const bool compress, const std::filesystem::path& dll_path)
+{
+    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);
+    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)
+{
+    const auto hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+    if (FAILED(hr)) return {};
+    Message("Initialize: loading file %s... ", modfile.c_str());
+    auto file_loader = ModfileLoader(modfile);
+    auto entries = file_loader.GetContents();
+    if (entries.empty()) {
+        Message("No entries found.\n");
+        return {};
+    }
+    Message("%zu textures... ", entries.size());
+    std::vector<gsl::owner<TextureFileStruct*>> texture_file_structs;
+    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);
+        texture_file_structs.push_back(tex_file_struct);
+        file_bytes_loaded += texture_file_structs.back()->data.size();
+    }
+    entries.clear();
+    Message("%d bytes loaded.\n", file_bytes_loaded);
+    CoUninitialize();
+    return texture_file_structs;
+}
+
+void TextureClient::LoadModsFromFile(const char* source)
+{
+    static std::vector<std::string> loaded_modfiles{};
+    Message("Initialize: searching in %s\n", source);
+
+    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::string line;
+    std::vector<std::string> modfiles;
+    while (std::getline(file, line)) {
+        // 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);
+        }
+    }
+    auto files_size = 0u;
+    for (const auto modfile : modfiles) {
+        if (std::filesystem::exists(modfile)) {
+            files_size += std::filesystem::file_size(modfile);
+        }
+    }
+    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));
+    }
+    auto loaded_size = 0u;
+    for (auto& future : futures) {
+        const auto texture_file_structs = future.get();
+        for (const auto texture_file_struct : texture_file_structs) {
+            if (!texture_file_struct->crc_hash) continue;
+            if (!modded_textures.contains(texture_file_struct->crc_hash)) {
+                modded_textures.emplace(texture_file_struct->crc_hash, texture_file_struct);
+                loaded_size += texture_file_struct->data.size();
+            }
+            else {
+                delete texture_file_struct;
+            }
+        }
+        should_update = true;
+    }
+    Message("Finished loading mods from %s: Loaded %u bytes (%u mb)", source, 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());
+        }
+    }
+    const auto t2 = std::chrono::high_resolution_clock::now();
+    const auto ms = duration_cast<std::chrono::milliseconds>(t2 - t1);
+    Info("Initialize: end, took %d ms\n", ms);
+}
+
+int TextureClient::AddTexture(uModTexturePtr auto pTexture)
+{
+    if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
+        SetLastCreatedTexture(nullptr);
+    }
+    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
+        SetLastCreatedVolumeTexture(nullptr);
+    }
+    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
+        SetLastCreatedCubeTexture(nullptr);
+    }
+
+    if (pTexture->FAKE) {
+        return RETURN_OK; // this is a fake texture
+    }
+
+    if (gl_ErrorState & uMod_ERROR_FATAL) {
+        return RETURN_FATAL_ERROR;
+    }
+
+    Message("TextureClient::AddTexture( Cube: %p): %p (thread: %u)\n", pTexture, this, GetCurrentThreadId());
+
+    pTexture->Hash = pTexture->GetHash();
+    if (!pTexture->Hash) {
+        return RETURN_FATAL_ERROR;
+    }
+
+    if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
+        OriginalTextures.push_back(pTexture);
+    }
+    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
+        OriginalVolumeTextures.push_back(pTexture);
+    }
+    else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
+        OriginalCubeTextures.push_back(pTexture);
+    }
+
+    return LookUpToMod(pTexture); // check if this texture should be modded
+}
+
+int TextureClient::RemoveTexture(uModTexturePtr auto pTexture)
+{
+    Message("TextureClient::RemoveTexture( %p, %#lX): %p\n", pTexture, pTexture->Hash, this);
+
+    if (gl_ErrorState & uMod_ERROR_FATAL) {
+        return RETURN_FATAL_ERROR;
+    }
+
+    if (!pTexture->FAKE) {
+        if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DTexture9*>) {
+            utils::erase_first(OriginalTextures, pTexture);
+        }
+        else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DVolumeTexture9*>) {
+            utils::erase_first(OriginalVolumeTextures, pTexture);
+        }
+        else if constexpr (std::same_as<decltype(pTexture), uMod_IDirect3DCubeTexture9*>) {
+            utils::erase_first(OriginalCubeTextures, pTexture);
+        }
+    }
+    if (!pTexture->Reference)
+        return RETURN_OK; // Should this ever happen?
+    return RETURN_OK;
+}
+
+int TextureClient::LookUpToMod(uModTexturePtr auto pTexture)
+{
+    Message("TextureClient::LookUpToMod( %p): hash: %#lX,  %p\n", pTexture, pTexture->Hash, this);
+    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);
+    if (found == modded_textures.end())
+        return ret;
+
+    const auto textureFileStruct = found->second;
+
+    decltype(pTexture) fake_Texture;
+    ret = LoadTexture(textureFileStruct, &fake_Texture);
+    if (ret != RETURN_OK)
+        return ret;
+
+    ret = SwitchTextures(fake_Texture, pTexture);
+    if (ret != RETURN_OK) {
+        Message("TextureClient::LookUpToMod(): textures not switched %#lX\n", textureFileStruct->crc_hash);
+        fake_Texture->Release();
+        return ret;
+    }
+    fake_Texture->Reference = textureFileStruct;
+    return ret;
+}
+
+int TextureClient::LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtrPtr auto ppTexture)
+{
+    Message("LoadTexture( %p, %p, %#lX): %p\n", file_in_memory, ppTexture, file_in_memory->crc_hash, this);
+    if (const auto ret = DirectX::CreateDDSTextureFromMemoryEx(
+        D3D9Device,
+        file_in_memory->data.data(),
+        file_in_memory->data.size(),
+        0, D3DPOOL_MANAGED, false,
+        reinterpret_cast<LPDIRECT3DTEXTURE9*>(ppTexture)); ret != D3D_OK) {
+        *ppTexture = nullptr;
+        Warning("LoadDDSTexture (%p, %#lX): FAILED ret: \n", file_in_memory->data.data(), file_in_memory->crc_hash, ret);
+        return RETURN_TEXTURE_NOT_LOADED;
+    }
+    if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DTexture9**>) {
+        SetLastCreatedTexture(nullptr);
+    }
+    else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DVolumeTexture9**>) {
+        SetLastCreatedVolumeTexture(nullptr);
+    }
+    else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DCubeTexture9**>) {
+        SetLastCreatedCubeTexture(nullptr);
+    }
+    (*ppTexture)->FAKE = true;
+
+    Message("LoadTexture (%p, %#lX): DONE\n", *ppTexture, file_in_memory->crc_hash);
+    return RETURN_OK;
+}

modules/TextureFunction.ixx

@@ -0,0 +1,321 @@
+module;
+
+#include "Main.h"
+#include <d3d9types.h>
+#include <DirectXTex/DirectXTex.h>
+
+export module TextureFunction;
+
+export template <typename T>
+concept uModTexturePtr = requires(T a)
+{
+    std::same_as<uMod_IDirect3DTexture9*, T> ||
+    std::same_as<uMod_IDirect3DVolumeTexture9*, T> ||
+    std::same_as<uMod_IDirect3DCubeTexture9*, T>;
+};
+
+export template <typename T>
+concept uModTexturePtrPtr = uModTexturePtr<std::remove_pointer_t<T>>;
+
+export template <typename T> requires uModTexturePtr<T>
+void UnswitchTextures(T pTexture)
+{
+    decltype(pTexture) CrossRef = pTexture->CrossRef_D3Dtex;
+    if (CrossRef != nullptr) {
+        std::swap(pTexture->m_D3Dtex, CrossRef->m_D3Dtex);
+
+        // cancel the link
+        CrossRef->CrossRef_D3Dtex = nullptr;
+        pTexture->CrossRef_D3Dtex = nullptr;
+    }
+}
+
+export template <typename T> requires uModTexturePtr<T>
+int SwitchTextures(T pTexture1, T pTexture2)
+{
+    if (pTexture1->m_D3Ddev == pTexture2->m_D3Ddev && pTexture1->CrossRef_D3Dtex == nullptr && pTexture2->CrossRef_D3Dtex == nullptr) {
+        // make cross reference
+        pTexture1->CrossRef_D3Dtex = pTexture2;
+        pTexture2->CrossRef_D3Dtex = pTexture1;
+
+        // switch textures
+        std::swap(pTexture1->m_D3Dtex, pTexture2->m_D3Dtex);
+        return RETURN_OK;
+    }
+    return RETURN_TEXTURE_NOT_SWITCHED;
+}
+
+export namespace TextureFunction {
+
+    unsigned int GetCRC32(char* pcDatabuf, unsigned int ulDatalen)
+    {
+        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 bit = 0u; bit < 8u; bit++, data >>= 1) {
+                crc = crc >> 1 ^ ((crc ^ data) & 1 ? crc32_poly : 0);
+            }
+        }
+        return crc;
+    }
+
+    int GetBitsFromFormat(D3DFORMAT format)
+    {
+        switch (format) //switch trough the formats to calculate the size of the raw data
+        {
+            case D3DFMT_A1: // 1-bit monochrome.
+            {
+                return 1;
+            }
+
+            case D3DFMT_R3G3B2: // 8-bit RGB texture format using 3 bits for red, 3 bits for green, and 2 bits for blue.
+            case D3DFMT_A8: // 8-bit alpha only.
+            case D3DFMT_A8P8: // 8-bit color indexed with 8 bits of alpha.
+            case D3DFMT_P8: // 8-bit color indexed.
+            case D3DFMT_L8: // 8-bit luminance only.
+            case D3DFMT_A4L4: // 8-bit using 4 bits each for alpha and luminance.
+            case D3DFMT_FORCE_DWORD:
+            case D3DFMT_S8_LOCKABLE: // A lockable 8-bit stencil buffer.
+            {
+                return 8;
+            }
+
+            case D3DFMT_D16_LOCKABLE: //16-bit z-buffer bit depth.
+            case D3DFMT_D15S1: // 16-bit z-buffer bit depth where 15 bits are reserved for the depth channel and 1 bit is reserved for the stencil channel.
+            case D3DFMT_L6V5U5: // 16-bit bump-map format with luminance using 6 bits for luminance, and 5 bits each for v and u.
+            case D3DFMT_V8U8: // 16-bit bump-map format using 8 bits each for u and v data.
+            case D3DFMT_CxV8U8: // 16-bit normal compression format. The texture sampler computes the C channel from: C = sqrt(1 - U2 - V2).
+            case D3DFMT_R5G6B5: // 16-bit RGB pixel format with 5 bits for red, 6 bits for green, and 5 bits for blue.
+            case D3DFMT_X1R5G5B5: // 16-bit pixel format where 5 bits are reserved for each color.
+            case D3DFMT_A1R5G5B5: // 16-bit pixel format where 5 bits are reserved for each color and 1 bit is reserved for alpha.
+            case D3DFMT_A4R4G4B4: // 16-bit ARGB pixel format with 4 bits for each channel.
+            case D3DFMT_A8R3G3B2: // 16-bit ARGB texture format using 8 bits for alpha, 3 bits each for red and green, and 2 bits for blue.
+            case D3DFMT_X4R4G4B4: // 16-bit RGB pixel format using 4 bits for each color.
+            case D3DFMT_L16: // 16-bit luminance only.
+            case D3DFMT_R16F: // 16-bit float format using 16 bits for the red channel.
+            case D3DFMT_A8L8: // 16-bit using 8 bits each for alpha and luminance.
+            case D3DFMT_D16: // 16-bit z-buffer bit depth.
+            case D3DFMT_INDEX16: // 16-bit index buffer bit depth.
+            case D3DFMT_G8R8_G8B8: // ??
+            case D3DFMT_R8G8_B8G8: // ??
+            case D3DFMT_UYVY: // ??
+            case D3DFMT_YUY2: // ??
+            {
+                return 16;
+            }
+
+
+            case D3DFMT_R8G8B8: //24-bit RGB pixel format with 8 bits per channel.
+            {
+                return 24;
+            }
+
+            case D3DFMT_R32F: // 32-bit float format using 32 bits for the red channel.
+            case D3DFMT_X8L8V8U8: // 32-bit bump-map format with luminance using 8 bits for each channel.
+            case D3DFMT_A2W10V10U10: // 32-bit bump-map format using 2 bits for alpha and 10 bits each for w, v, and u.
+            case D3DFMT_Q8W8V8U8: // 32-bit bump-map format using 8 bits for each channel.
+            case D3DFMT_V16U16: // 32-bit bump-map format using 16 bits for each channel.
+            case D3DFMT_A8R8G8B8: // 32-bit ARGB pixel format with alpha, using 8 bits per channel.
+            case D3DFMT_X8R8G8B8: // 32-bit RGB pixel format, where 8 bits are reserved for each color.
+            case D3DFMT_A2B10G10R10: // 32-bit pixel format using 10 bits for each color and 2 bits for alpha.
+            case D3DFMT_A8B8G8R8: // 32-bit ARGB pixel format with alpha, using 8 bits per channel.
+            case D3DFMT_X8B8G8R8: // 32-bit RGB pixel format, where 8 bits are reserved for each color.
+            case D3DFMT_G16R16: // 32-bit pixel format using 16 bits each for green and red.
+            case D3DFMT_G16R16F: // 32-bit float format using 16 bits for the red channel and 16 bits for the green channel.
+            case D3DFMT_A2R10G10B10: // 32-bit pixel format using 10 bits each for red, green, and blue, and 2 bits for alpha.
+            case D3DFMT_D32: // 32-bit z-buffer bit depth.
+            case D3DFMT_D24S8: // 32-bit z-buffer bit depth using 24 bits for the depth channel and 8 bits for the stencil channel.
+            case D3DFMT_D24X8: //32-bit z-buffer bit depth using 24 bits for the depth channel.
+            case D3DFMT_D24X4S4: // 32-bit z-buffer bit depth using 24 bits for the depth channel and 4 bits for the stencil channel.
+            case D3DFMT_D32F_LOCKABLE: // A lockable format where the depth value is represented as a standard IEEE floating-point number.
+            case D3DFMT_D24FS8: // A non-lockable format that contains 24 bits of depth (in a 24-bit floating point format - 20e4) and 8 bits of stencil.
+            case D3DFMT_D32_LOCKABLE: // A lockable 32-bit depth buffer.
+            case D3DFMT_INDEX32: // 32-bit index buffer bit depth.
+            {
+                return 32;
+            }
+
+            case D3DFMT_G32R32F: // 64-bit float format using 32 bits for the red channel and 32 bits for the green channel.
+            case D3DFMT_Q16W16V16U16: // 64-bit bump-map format using 16 bits for each component.
+            case D3DFMT_A16B16G16R16: // 64-bit pixel format using 16 bits for each component.
+            case D3DFMT_A16B16G16R16F: // 64-bit float format using 16 bits for the each channel (alpha, blue, green, red).
+            {
+                return 64;
+            }
+
+            case D3DFMT_A32B32G32R32F: // 128-bit float format using 32 bits for the each channel (alpha, blue, green, red).
+            {
+                return 128;
+            }
+            case D3DFMT_DXT2:
+            case D3DFMT_DXT3:
+            case D3DFMT_DXT4:
+            case D3DFMT_DXT5: {
+                return 8;
+            }
+            case D3DFMT_DXT1: {
+                return 4;
+            }
+            default: //compressed formats
+            {
+                return 4;
+            }
+        }
+    }
+
+    DirectX::ScratchImage ImageConvertToBGRA(DirectX::ScratchImage& image, const TexEntry& entry)
+    {
+        if (image.GetMetadata().format == DXGI_FORMAT_B8G8R8A8_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC1_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC2_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC3_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC4_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC5_UNORM) {
+            return std::move(image);
+        }
+        DirectX::ScratchImage bgra_image;
+        const HRESULT hr = DirectX::Convert(
+            image.GetImages(),
+            image.GetImageCount(),
+            image.GetMetadata(),
+            DXGI_FORMAT_B8G8R8A8_UNORM,
+            DirectX::TEX_FILTER_DEFAULT,
+            DirectX::TEX_THRESHOLD_DEFAULT,
+            bgra_image);
+        if (FAILED(hr)) {
+            Warning("ImageConvertToBGRA (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            bgra_image = std::move(image);
+        }
+        image.Release();
+        return bgra_image;
+    }
+
+    DirectX::ScratchImage ImageGenerateMipMaps(DirectX::ScratchImage& image, const TexEntry& entry)
+    {
+        if (entry.ext == ".dds") {
+            return std::move(image);
+        }
+        DirectX::ScratchImage mipmapped_image;
+        const auto hr = DirectX::GenerateMipMaps(
+            image.GetImages(),
+            image.GetImageCount(),
+            image.GetMetadata(),
+            DirectX::TEX_FILTER_DEFAULT,
+            0,
+            mipmapped_image);
+        if (FAILED(hr)) {
+            Warning("GenerateMipMaps (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            mipmapped_image = std::move(image);
+        }
+        image.Release();
+        return mipmapped_image;
+    }
+
+    DirectX::ScratchImage ImageCompress(DirectX::ScratchImage& image, const TexEntry& entry)
+    {
+        if (image.GetMetadata().format == DXGI_FORMAT_BC1_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC2_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC3_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC4_UNORM ||
+            image.GetMetadata().format == DXGI_FORMAT_BC5_UNORM) {
+            return std::move(image);
+        }
+        DirectX::ScratchImage compressed_image;
+        const auto hr = DirectX::Compress(
+            image.GetImages(),
+            image.GetImageCount(),
+            image.GetMetadata(),
+            DXGI_FORMAT_BC3_UNORM,
+            DirectX::TEX_COMPRESS_DEFAULT,
+            DirectX::TEX_THRESHOLD_DEFAULT,
+            compressed_image);
+        if (FAILED(hr)) {
+            Warning("ImageCompress (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            compressed_image = std::move(image);
+        }
+        image.Release();
+        return compressed_image;
+    }
+
+    void ImageSave(const DirectX::ScratchImage& image, const TexEntry& entry, const std::filesystem::path& dll_path)
+    {
+        const auto file_name = std::format("0x{:x}.dds", entry.crc_hash);
+        const auto file_out = dll_path / "textures" / file_name;
+        try {
+            if (std::filesystem::exists(file_out)) {
+                return;
+            }
+            if (!std::filesystem::exists(file_out.parent_path())) {
+                std::filesystem::create_directory(file_out.parent_path());
+            }
+            const auto hr = DirectX::SaveToDDSFile(
+                image.GetImages(),
+                image.GetImageCount(),
+                image.GetMetadata(),
+                DirectX::DDS_FLAGS_NONE,
+                file_out.c_str());
+            if (FAILED(hr)) {
+                Warning("SaveDDSImageToDisk (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            }
+        }
+        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::ScratchImage image;
+        HRESULT hr = 0;
+
+        if (entry.ext == ".dds") {
+            hr = DirectX::LoadFromDDSMemory(entry.data.data(), entry.data.size(), DirectX::DDS_FLAGS_NONE, nullptr, image);
+        }
+        else if (entry.ext == ".tga") {
+            hr = DirectX::LoadFromTGAMemory(entry.data.data(), entry.data.size(), DirectX::TGA_FLAGS_BGR, nullptr, image);
+        }
+        else if (entry.ext == ".hdr") {
+            hr = DirectX::LoadFromHDRMemory(entry.data.data(), entry.data.size(), nullptr, image);
+        }
+        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;
+                }
+            }
+        }
+        entry.data.clear();
+        if (FAILED(hr)) {
+            Warning("LoadImageFromMemory (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            return {};
+        }
+
+        auto bgra_image = ImageConvertToBGRA(image, entry);
+        auto mipmapped_image = ImageGenerateMipMaps(bgra_image, entry);
+        const auto compressed_image = compress ? ImageCompress(mipmapped_image, entry) : std::move(mipmapped_image);
+
+        DirectX::Blob dds_blob;
+        hr = DirectX::SaveToDDSMemory(
+            compressed_image.GetImages(),
+            compressed_image.GetImageCount(),
+            compressed_image.GetMetadata(),
+            DirectX::DDS_FLAGS_NONE,
+            dds_blob);
+        if (FAILED(hr)) {
+            Warning("SaveDDSImageToMemory (%#lX%s): FAILED\n", entry.crc_hash, entry.ext.c_str());
+            return {};
+        }
+
+    #ifdef _DEBUG
+        ImageSave(compressed_image, entry, dll_path);
+    #endif
+        return dds_blob;
+    }
+}

source/Error.cpp

@@ -1,8 +1,9 @@
 #include "Error.h"
 
 #include <Windows.h>
-#include <stdio.h>
+#include <cstdio>
 #include <process.h>
+#include <Main.h>
 
 __declspec(noreturn) void FatalAssert(
 const char *expr,
@@ -10,13 +11,20 @@ const char *file,
 unsigned int line,
 const char *function)
 {
-    const char* fmt = "%s\n%s\n%s line %d";
-    int len = snprintf(NULL, 0, fmt, expr, file, function, line);
-
+    char module_path[MAX_PATH]{};
+    if (gl_hThisInstance) {
+        GetModuleFileName(gl_hThisInstance, module_path, _countof(module_path));
+    }
+    if (!*module_path) {
+        strcpy(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);
     char* buf = new char[len + 1];
-    snprintf(buf,len + 1, fmt, expr, file, function, line);
+    snprintf(buf,len + 1, fmt, module_path, expr, file, function, line);
 
-    MessageBox(0, "uMod Assertion", buf, MB_OK | MB_ICONERROR);
+
+    MessageBox(0, buf, "uMod Assertion Failure", MB_OK | MB_ICONERROR);
 
     delete[] buf;
     abort();

source/FileLoader.cpp

@@ -1,185 +0,0 @@
-#include <..\header\Main.h>
-#include <filesystem>
-#include "FileLoader.h"
-#include "TpfReader.h"
-
-FileLoader::FileLoader(const std::string& fileName)
-{
-    file_name = std::filesystem::absolute(fileName).string();
-}
-
-std::vector<TpfEntry> FileLoader::GetContents()
-{
-    try {
-        return file_name.ends_with(".tpf") ? GetTpfContents() : GetFileContents();
-    }
-    catch (const std::exception&) {
-        Message("Failed to open mod file: %s\n", file_name.c_str());
-    }
-    return {};
-}
-
-std::vector<TpfEntry> FileLoader::GetTpfContents()
-{
-    std::vector<TpfEntry> 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) {
-        Message("Failed to open tpf file: %s - %u bytes!", file_name.c_str(), buffer.size());
-        return {};
-    }
-    zip_archive->setErrorHandlerCallback(
-        [](const std::string& message, const std::string& strerror, int zip_error_code, int system_error_code) -> void {
-            Message("GetTpfContents: %s %s %d %d\n", message.c_str(), strerror.c_str(), 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<TpfEntry> FileLoader::GetFileContents()
-{
-    std::vector<TpfEntry> entries;
-
-    libzippp::ZipArchive zip_archive(file_name);
-    zip_archive.open();
-    LoadEntries(zip_archive, entries);
-    zip_archive.close();
-
-    return entries;
-}
-
-void ParseSimpleArchive(const libzippp::ZipArchive& archive, std::vector<TpfEntry>& entries)
-{
-    for (const auto& entry : archive.getEntries()) {
-        if (entry.isFile()) {
-            //TODO: #6 - Implement regex search
-            auto name = entry.getName();
-
-            // Remove the part before the last underscore (if any)
-            size_t firstIndex = name.find_last_of('_');
-            while (firstIndex != std::string::npos) {
-                if (firstIndex >= entry.getName().length() - 1) {
-                    name = entry.getName();
-                }
-                else {
-                    name = entry.getName().substr(firstIndex + 1);
-                }
-
-                firstIndex = name.find_last_of('_');
-            }
-
-            // Remove the file extension (if any)
-            size_t lastIndex = name.find_last_of('.');
-            if (lastIndex != std::string::npos) {
-                name = name.substr(0, lastIndex);
-            }
-
-            uint32_t crc_hash;
-            try {
-                crc_hash = std::stoul(name, nullptr, 16);
-            }
-            catch (const std::invalid_argument& e) {
-                Message("Failed to parse %s as a hash", name.c_str());
-                continue;
-            }
-            catch (const std::out_of_range& e) {
-                Message("Out of range while parsing %s as a hash", name.c_str());
-                continue;
-            }
-
-            const auto data_ptr = static_cast<char*>(entry.readAsBinary());
-            const auto size = entry.getSize();
-            std::vector<char> vec;
-            vec.assign(data_ptr, data_ptr + size);
-            entries.emplace_back(name, entry.getName(), crc_hash, std::move(vec));
-        }
-    }
-}
-
-void ParseTexmodArchive(std::vector<std::string>& lines, libzippp::ZipArchive& archive, std::vector<TpfEntry>& entries)
-{
-    for (const auto& line : lines) {
-        std::istringstream iss(line);
-        std::string part;
-        std::vector<std::string> splits;
-
-        // Split the line by '|'
-        while (std::getline(iss, part, '|')) {
-            splits.push_back(part);
-        }
-
-        if (splits.size() != 2) {
-            continue;
-        }
-
-        std::string addrstr = splits[0];
-        std::string path = splits[1];
-
-        // Remove unwanted characters from the beginning of the path
-        while (!path.empty() && (path[0] == '.' && (path[1] == '/' || path[1] == '\\')) || path[0] == '/' || path[0] == '\\') {
-            path.erase(0, 1);
-        }
-
-        // Remove trailing newline and carriage return characters
-        if (const auto end_pos = path.find_last_not_of("\r\n"); end_pos != std::string::npos) {
-            path.erase(end_pos + 1);
-        }
-        else if (!path.empty()) {
-            path.clear();
-        }
-
-        const auto entry = archive.getEntry(path);
-        if (entry.isNull()) {
-            continue;
-        }
-
-        if (!entry.isFile()) {
-            continue;
-        }
-
-        uint32_t crc_hash{};
-        try {
-            crc_hash = std::stoul(addrstr, nullptr, 16);
-        }
-        catch (const std::invalid_argument& e) {
-            Message("Failed to parse %s as a hash", addrstr.c_str());
-            continue;
-        }
-        catch (const std::out_of_range& e) {
-            Message("Out of range while parsing %s as a hash", addrstr.c_str());
-            continue;
-        }
-
-        const auto data_ptr = static_cast<char*>(entry.readAsBinary());
-        const auto size = static_cast<size_t>(entry.getSize());
-        std::vector vec(data_ptr, data_ptr + size);
-        entries.emplace_back(addrstr, entry.getName(), crc_hash, std::move(vec));
-        delete[] data_ptr;
-    }
-}
-
-void FileLoader::LoadEntries(libzippp::ZipArchive& archive, std::vector<TpfEntry>& entries)
-{
-    // Iterate over the files in the zip archive
-    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);
-    }
-}

source/TextureClient.cpp

@@ -1,208 +0,0 @@
-#include <filesystem>
-#include <fstream>
-
-#include "Main.h"
-
-TextureClient::TextureClient(IDirect3DDevice9* device)
-{
-    Message("TextureClient::TextureClient(): %p\n", this);
-    D3D9Device = device;
-
-    void* cpy;
-    isDirectXExDevice = D3D9Device->QueryInterface(IID_IDirect3DTexture9, &cpy) == 0x01000001L;
-
-    Mutex = CreateMutex(nullptr, false, nullptr);
-
-    FontColour = D3DCOLOR_ARGB(255, 255, 0, 0);
-    TextureColour = D3DCOLOR_ARGB(255, 0, 255, 0);
-}
-
-TextureClient::~TextureClient()
-{
-    Message("TextureClient::~TextureClient(): %p\n", this);
-    if (Mutex != nullptr) {
-        CloseHandle(Mutex);
-    }
-    for (const auto& it : modded_textures) {
-        delete it.second;
-    }
-    modded_textures.clear();
-}
-
-int TextureClient::MergeUpdate()
-{
-    if (!should_update) return RETURN_OK;
-    should_update = false;
-    if (const int ret = LockMutex()) {
-        gl_ErrorState |= uMod_ERROR_TEXTURE;
-        return ret;
-    }
-
-    Message("MergeUpdate(): %p\n", this);
-
-    const auto single_texture = GetSingleTexture();
-    for (const auto pTexture : OriginalTextures) {
-        if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_texture) {
-            UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
-            LookUpToMod(pTexture);
-        }
-    }
-    const auto single_volume_texture = GetSingleVolumeTexture();
-    for (const auto pTexture : OriginalVolumeTextures) {
-        if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_volume_texture) {
-            UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
-            LookUpToMod(pTexture);
-        }
-    }
-    const auto single_cube_texture = GetSingleCubeTexture();
-    for (const auto pTexture : OriginalCubeTextures) {
-        if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_cube_texture) {
-            UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
-            LookUpToMod(pTexture);
-        }
-    }
-
-    return UnlockMutex();
-}
-
-uMod_IDirect3DTexture9* TextureClient::GetSingleTexture()
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleTexture();
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleTexture();
-}
-
-uMod_IDirect3DVolumeTexture9* TextureClient::GetSingleVolumeTexture()
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleVolumeTexture();
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleVolumeTexture();
-}
-
-uMod_IDirect3DCubeTexture9* TextureClient::GetSingleCubeTexture()
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleCubeTexture();
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleCubeTexture();
-}
-
-int TextureClient::SetLastCreatedTexture(uMod_IDirect3DTexture9* texture)
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedTexture(texture);
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedTexture(texture);
-}
-
-int TextureClient::SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* texture)
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
-}
-
-int TextureClient::SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* texture)
-{
-    if (isDirectXExDevice)
-        return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
-    //this texture must no be added twice
-    return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
-}
-
-
-int TextureClient::LockMutex()
-{
-    if ((gl_ErrorState & (uMod_ERROR_FATAL | uMod_ERROR_MUTEX))) {
-        return RETURN_NO_MUTEX;
-    }
-    if (WAIT_OBJECT_0 != WaitForSingleObject(Mutex, 100)) {
-        return RETURN_MUTEX_LOCK; //waiting 100ms, to wait infinite pass INFINITE
-    }
-    return RETURN_OK;
-}
-
-int TextureClient::UnlockMutex()
-{
-    if (ReleaseMutex(Mutex) == 0) {
-        return RETURN_MUTEX_UNLOCK;
-    }
-    return RETURN_OK;
-}
-
-unsigned long TextureClient::AddFile(TpfEntry& entry)
-{
-    if (modded_textures.contains(entry.crc_hash)) {
-        return 0;
-    }
-    TextureFileStruct* texture_file_struct = new TextureFileStruct();
-    texture_file_struct->data = std::move(entry.data);
-    texture_file_struct->crc_hash = entry.crc_hash;
-    modded_textures.emplace(entry.crc_hash, texture_file_struct);
-    should_update = true;
-    return texture_file_struct->data.size();
-}
-
-void TextureClient::LoadModsFromFile(const char* source)
-{
-    static unsigned long loaded_size = 0;
-    Message("Initialize: searching in %s\n", source);
-
-    std::ifstream file(source);
-    if (!file.is_open()) {
-        Message("LoadModsFromFile: failed to open modlist.txt for reading; aborting!!!");
-        return;
-    }
-    Message("Initialize: found modlist.txt. Reading\n");
-    std::string line;
-    while (std::getline(file, line)) {
-        Message("Initialize: loading file %s... ", line.c_str());
-
-        // Remove newline character
-        line.erase(std::ranges::remove(line, '\n').begin(), line.end());
-
-        auto file_loader = FileLoader(line);
-        auto entries = file_loader.GetContents();
-        if (loaded_size > 1'500'000'000) {
-            Message("LoadModsFromFile: Loaded %d bytes, aborting!!!\n", loaded_size);
-            return;
-        }
-        if (entries.empty()) {
-            Message("No entries found.\n");
-            continue;
-        }
-        Message("%zu textures... ", entries.size());
-        unsigned long file_bytes_loaded = 0;
-        for (auto& tpf_entry : entries) {
-            file_bytes_loaded += AddFile(tpf_entry);
-        }
-        entries.clear();
-        Message("%d bytes loaded.\n", file_bytes_loaded);
-        loaded_size += file_bytes_loaded;
-    }
-    Message("Finished loading mods from %s: Loaded %u bytes (%u mb)", source, loaded_size, loaded_size / 1024 / 1024);
-}
-
-void TextureClient::Initialize()
-{
-    Message("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
-    const auto exe = std::filesystem::path(gwpath).parent_path();
-    const auto dll = std::filesystem::path(dllpath).parent_path();
-    for (const auto& path : {exe, dll}) {
-        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());
-        }
-    }
-
-    Message("Initialize: end\n");
-}

source/dll_main.cpp

@@ -1,52 +1,33 @@
-#include "dll_main.h"
-
-#include <array>
-#include <Windows.h>
 #include "Main.h"
 #include <Psapi.h>
-
 #include "MinHook.h"
 
+void ExitInstance();
+void InitInstance(HINSTANCE hModule);
+
 namespace {
 
+    #define DISABLE_HOOK(var) if(var) { MH_DisableHook(var);}
+
     using Direct3DCreate9_type = IDirect3D9* (APIENTRY*)(UINT);
     using Direct3DCreate9Ex_type = HRESULT(APIENTRY*)(UINT SDKVersion, IDirect3D9Ex** ppD3D);
+    using GetProcAddress_type = FARPROC(APIENTRY*)(HMODULE, LPCSTR);
 
     // Pointer to original address of Direct3DCreate9
-    Direct3DCreate9_type Direct3DCreate9_fn = nullptr;
     Direct3DCreate9_type Direct3DCreate9_ret = nullptr;
 
     // Pointer to original address of Direct3DCreate9
-    Direct3DCreate9Ex_type Direct3DCreate9Ex_fn = nullptr;
     Direct3DCreate9Ex_type Direct3DCreate9Ex_ret = nullptr;
 
-    static FILE* stdout_proxy;
-    static FILE* stderr_proxy;
+    GetProcAddress_type GetProcAddress_fn = nullptr;
+    GetProcAddress_type GetProcAddress_ret = nullptr;
 
-    /*
-    * global variable which are linked external
-    */
-    unsigned int gl_ErrorState = 0u;
+    FILE* stdout_proxy;
+    FILE* stderr_proxy;
 
-    // If not nullptr, we're responsible for freeing this library on termination
-    HMODULE gl_hOriginalDll = nullptr;
+    HMODULE gMod_Loaded_d3d9_Module_Handle = nullptr;
 
-    // If this hModule called d3d9.dll?
-    bool IsD3d9Module(HMODULE hModule, HANDLE hProcess)
-    {
-        TCHAR szModuleName[MAX_PATH];
-        GetModuleBaseName(hProcess, hModule, szModuleName, sizeof(szModuleName) / sizeof(TCHAR));
-        return strcmp(szModuleName, TEXT("d3d9.dll")) == 0;
-    }
-    // Does this module contain exported function calls for creating a d3d9 device?
-    bool HasD3d9Methods(HMODULE hModule, HANDLE hProcess)
-    {
-        return GetProcAddress(hModule, "Direct3DCreate9")
-            && GetProcAddress(hModule, "Direct3DCreate9Ex");
-    }
-
-
-    HMODULE FindLoadedDll()
+    HMODULE FindLoadedModuleByName(const char* name, bool include_this_module = false)
     {
         HMODULE hModules[1024];
         HANDLE hProcess;
@@ -58,18 +39,140 @@ namespace {
         if (!EnumProcessModules(hProcess, hModules, sizeof(hModules), &cbNeeded))
             return nullptr;
         for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
-            if (IsD3d9Module(hModules[i], hProcess)
-                || HasD3d9Methods(hModules[i], hProcess)) {
+            if (hModules[i] == gl_hThisInstance && !include_this_module)
+                continue;
+            TCHAR szModuleName[MAX_PATH];
+            ASSERT(GetModuleFileName(hModules[i], szModuleName, _countof(szModuleName)) > 0);
+            const auto basename = strrchr(szModuleName, '\\');
+            if (basename && stricmp(basename + 1, name) == 0)
                 return hModules[i];
-            }
         }
         return nullptr;
     }
+
+    HMODULE LoadD3d9Dll()
+    {
+        HMODULE found = FindLoadedModuleByName("d3d9.dll");
+        if (!found) {
+            char executable_path[MAX_PATH]{};
+            ASSERT(GetModuleFileName(GetModuleHandle(nullptr), executable_path, _countof(executable_path)) > 0);
+
+            char dll_path[MAX_PATH]{};
+            ASSERT(GetModuleFileName(gl_hThisInstance, dll_path, _countof(dll_path)) > 0);
+
+            const auto exe_path = std::filesystem::path(executable_path);
+            const auto gmod_path = std::filesystem::path(dll_path);
+
+            if (exe_path.parent_path() != gmod_path.parent_path()
+                || gmod_path.filename() != "d3d9.dll") {
+                // Call basic LoadLibrary function; we're not in the same directory as the exe.
+                gMod_Loaded_d3d9_Module_Handle = LoadLibrary("d3d9.dll");
+            }
+            if (!gMod_Loaded_d3d9_Module_Handle) {
+                // Tried resolving d3d9.dll locally, didn't work. Try system directory
+                char buffer[MAX_PATH];
+                ASSERT(GetSystemDirectory(buffer, _countof(buffer)) > 0); //get the system directory, we need to open the original d3d9.dll
+
+                // Append dll name
+                strcat_s(buffer, _countof(buffer), "\\d3d9.dll");
+                gMod_Loaded_d3d9_Module_Handle = LoadLibrary(buffer);
+            }
+
+            ASSERT(gMod_Loaded_d3d9_Module_Handle);
+
+            found = FindLoadedModuleByName("d3d9.dll");
+            ASSERT(found && found == gMod_Loaded_d3d9_Module_Handle);
+        }
+
+        DISABLE_HOOK(GetProcAddress_fn);
+        // GetProcAddress, hooked via OnGetProcAddress
+        Direct3DCreate9_ret = reinterpret_cast<Direct3DCreate9_type>(GetProcAddress(found, "Direct3DCreate9"));
+        Direct3DCreate9Ex_ret = reinterpret_cast<Direct3DCreate9Ex_type>(GetProcAddress(found, "Direct3DCreate9Ex"));
+
+        return found;
+    }
+
+    FARPROC APIENTRY OnGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
+    {
+        ASSERT(GetProcAddress_ret);
+        if ((int)lpProcName < 0xffff)
+            return GetProcAddress_ret(hModule, lpProcName); // lpProcName is ordinal offset, not string
+
+        if (strcmp(lpProcName, "Direct3DCreate9") == 0) {
+            Direct3DCreate9_ret = reinterpret_cast<Direct3DCreate9_type>(GetProcAddress_ret(hModule, lpProcName));
+            return reinterpret_cast<FARPROC>(Direct3DCreate9);
+        }
+        if (strcmp(lpProcName, "Direct3DCreate9Ex") == 0) {
+            Direct3DCreate9Ex_ret = reinterpret_cast<Direct3DCreate9Ex_type>(GetProcAddress_ret(hModule, lpProcName));
+            return reinterpret_cast<FARPROC>(Direct3DCreate9Ex);
+        }
+        return GetProcAddress_ret(hModule, lpProcName);
+    }
+
+    // If the original d3d9 function is nullptr or points to gMod, load the actual d3d9 dll and redirect the addresses
+    void CheckLoadD3d9Dll()
+    {
+        if (!(Direct3DCreate9_ret && Direct3DCreate9_ret != Direct3DCreate9)) {
+            ASSERT(LoadD3d9Dll());
+            ASSERT(Direct3DCreate9_ret && Direct3DCreate9_ret != Direct3DCreate9);
+        }
+        if (!(Direct3DCreate9Ex_ret && Direct3DCreate9Ex_ret != Direct3DCreate9Ex)) {
+            ASSERT(LoadD3d9Dll());
+            ASSERT(Direct3DCreate9Ex_ret && Direct3DCreate9Ex_ret != Direct3DCreate9Ex);
+        }
+    }
+
+    // There may be a sitation where more than 1 gmod is loaded; avoid recursions!
+    bool creating_d3d9 = false;
 }
 
 unsigned int gl_ErrorState = 0;
 HINSTANCE gl_hThisInstance = nullptr;
 
+IDirect3D9* APIENTRY Direct3DCreate9(UINT SDKVersion)
+{
+    Message("uMod_Direct3DCreate9: uMod %p\n", Direct3DCreate9);
+
+    ASSERT(!creating_d3d9);
+    creating_d3d9 = true;
+
+    DISABLE_HOOK(GetProcAddress_fn);
+    CheckLoadD3d9Dll();
+
+    IDirect3D9* pIDirect3D9_orig = Direct3DCreate9_ret(SDKVersion); //creating the original IDirect3D9 object
+    ASSERT(pIDirect3D9_orig);
+
+    creating_d3d9 = false;
+
+    return new uMod_IDirect3D9(pIDirect3D9_orig); //return our object instead of the "real one"
+}
+
+HRESULT APIENTRY Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex** ppD3D)
+{
+    Message("uMod_Direct3DCreate9Ex: uMod %p\n", Direct3DCreate9Ex);
+
+    ASSERT(!creating_d3d9);
+    creating_d3d9 = true;
+
+
+    DISABLE_HOOK(GetProcAddress_fn);
+    CheckLoadD3d9Dll();
+
+    IDirect3D9Ex* pIDirect3D9Ex_orig = nullptr;
+    HRESULT ret = Direct3DCreate9Ex_ret(SDKVersion, &pIDirect3D9Ex_orig); //creating the original IDirect3D9 object
+
+    creating_d3d9 = false;
+
+    if (ret != S_OK)
+        return ret;
+
+    // @Cleanup: should be we freeing pIDirect3D9Ex at the end of our own lifecycle?
+    const auto pIDirect3D9Ex = new uMod_IDirect3D9Ex(pIDirect3D9Ex_orig);
+    // original umod does not do this for some reason
+    *ppD3D = static_cast<IDirect3D9Ex*>(pIDirect3D9Ex);
+    return ret;
+}
+
 /*
  * dll entry routine, here we initialize or clean up
  */
@@ -80,10 +183,10 @@ BOOL WINAPI DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
     switch (ul_reason_for_call) {
         case DLL_PROCESS_ATTACH: {
 #ifdef _DEBUG
-        AllocConsole();
-        SetConsoleTitleA("gMod Console");
-        freopen_s(&stdout_proxy, "CONOUT$", "w", stdout);
-        freopen_s(&stderr_proxy, "CONOUT$", "w", stderr);
+            AllocConsole();
+            SetConsoleTitleA("gMod Console");
+            freopen_s(&stdout_proxy, "CONOUT$", "w", stdout);
+            freopen_s(&stderr_proxy, "CONOUT$", "w", stderr);
 #endif
             InitInstance(hModule);
             break;
@@ -100,104 +203,44 @@ BOOL WINAPI DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
 
 void InitInstance(HINSTANCE hModule)
 {
-    DisableThreadLibraryCalls(hModule); //reduce overhead
-    gl_hThisInstance = hModule;
     Message("InitInstance: %p\n", hModule);
+    DisableThreadLibraryCalls(hModule); //reduce overhead
 
-    const auto d3d9_dll = LoadOriginalDll();
-    ASSERT(d3d9_dll);
+    // Store the handle to this module
+    gl_hThisInstance = hModule;
 
-    Direct3DCreate9_fn = reinterpret_cast<Direct3DCreate9_type>(GetProcAddress(d3d9_dll, "Direct3DCreate9"));
-    ASSERT(Direct3DCreate9_fn);
-
-    Direct3DCreate9Ex_fn = reinterpret_cast<Direct3DCreate9Ex_type>(GetProcAddress(d3d9_dll, "Direct3DCreate9Ex"));
-    ASSERT(Direct3DCreate9Ex_fn);
+    // d3d9.dll shouldn't be loaded at this point.
+    const auto d3d9_loaded = FindLoadedModuleByName("d3d9.dll");
+    ASSERT(!d3d9_loaded);
 
     MH_Initialize();
 
-    if (Direct3DCreate9_fn) {
-        MH_CreateHook(Direct3DCreate9_fn, uMod_Direct3DCreate9, (void**)&Direct3DCreate9_ret);
-        MH_EnableHook(Direct3DCreate9_fn);
+    // Hook into LoadLibraryA - we'll do our hooks on the flip side
+    GetProcAddress_fn = reinterpret_cast<GetProcAddress_type>(GetProcAddress);
+    ASSERT(GetProcAddress_fn);
+    if (GetProcAddress_fn) {
+        MH_CreateHook(GetProcAddress_fn, OnGetProcAddress, (void**)&GetProcAddress_ret);
+        MH_EnableHook(GetProcAddress_fn);
     }
-
-    if (Direct3DCreate9Ex_fn) {
-        MH_CreateHook(Direct3DCreate9Ex_fn, uMod_Direct3DCreate9Ex, (void**)&Direct3DCreate9Ex_ret);
-        MH_EnableHook(Direct3DCreate9Ex_fn);
-    }
-
 }
+
 void ExitInstance()
 {
-    if(Direct3DCreate9_fn)
-        MH_DisableHook(Direct3DCreate9_fn);
-    if(Direct3DCreate9Ex_fn)
-        MH_DisableHook(Direct3DCreate9Ex_fn);
+    DISABLE_HOOK(GetProcAddress_fn);
 
     MH_Uninitialize();
 
-    // Release the system's d3d9.dll
-    if (gl_hOriginalDll != nullptr) {
-        FreeLibrary(gl_hOriginalDll);
-        gl_hOriginalDll = nullptr;
-    }
+    if (gMod_Loaded_d3d9_Module_Handle)
+        FreeLibrary(gMod_Loaded_d3d9_Module_Handle);
 
 #ifdef _DEBUG
     if (stdout_proxy)
         fclose(stdout_proxy);
     if (stderr_proxy)
         fclose(stderr_proxy);
-    FreeConsole();
+    __try {
+        FreeConsole();
+    }
+    __except (EXCEPTION_CONTINUE_EXECUTION) { }
 #endif
 }
-
-HMODULE LoadOriginalDll()
-{
-    HMODULE found = FindLoadedDll();
-    if (found)
-        return found;
-
-    char buffer[MAX_PATH];
-    GetSystemDirectory(buffer, MAX_PATH); //get the system directory, we need to open the original d3d9.dll
-
-    // Append dll name
-    strcat_s(buffer, MAX_PATH, "\\d3d9.dll");
-    gl_hOriginalDll = LoadLibrary(buffer);
-    found = FindLoadedDll();
-    ASSERT(found && found == gl_hOriginalDll);
-
-    return found;
-}
-
-/*
- * We inject the dll into the game, thus we retour the original Direct3DCreate9 function to our MyDirect3DCreate9 function
- */
-
-IDirect3D9* APIENTRY uMod_Direct3DCreate9(UINT SDKVersion)
-{
-    Message("uMod_Direct3DCreate9:  original %p, uMod %p\n", Direct3DCreate9_fn, uMod_Direct3DCreate9);
-
-    ASSERT(Direct3DCreate9_ret);
-
-    IDirect3D9* pIDirect3D9_orig = Direct3DCreate9_ret(SDKVersion); //creating the original IDirect3D9 object
-    ASSERT(pIDirect3D9_orig);
-
-    return new uMod_IDirect3D9(pIDirect3D9_orig); //return our object instead of the "real one"
-}
-
-HRESULT APIENTRY uMod_Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex** ppD3D)
-{
-    Message("uMod_Direct3DCreate9Ex:  original %p, uMod %p\n", Direct3DCreate9Ex_fn, uMod_Direct3DCreate9Ex);
-
-    ASSERT(Direct3DCreate9Ex_ret);
-
-    IDirect3D9Ex* pIDirect3D9Ex_orig = nullptr;
-    HRESULT ret = Direct3DCreate9Ex_ret(SDKVersion, &pIDirect3D9Ex_orig); //creating the original IDirect3D9 object
-
-    if (ret != S_OK)
-        return ret;
-
-    // @Cleanup: should be we freeing pIDirect3D9Ex at the end of our own lifecycle?
-    uMod_IDirect3D9Ex* pIDirect3D9Ex = new uMod_IDirect3D9Ex(pIDirect3D9Ex_orig);
-    ppD3D = (IDirect3D9Ex**)&pIDirect3D9Ex;
-    return ret;
-}

source/uMod_IDirect3DCubeTexture9.cpp

@@ -1,5 +1,8 @@
 #include "Main.h"
 
+import TextureFunction;
+import TextureClient;
+
 //this function yields for the non switched texture object
 HRESULT APIENTRY uMod_IDirect3DCubeTexture9::QueryInterface(REFIID riid, void** ppvObj)
 {
@@ -62,16 +65,7 @@ ULONG APIENTRY uMod_IDirect3DCubeTexture9::Release()
             if (count == 0) //if texture is released we switch the textures back
             {
                 UnswitchTextures(this);
-                if (ret == 0x01000000L) {
-                    if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleCubeTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
-                else {
-                    if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleCubeTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
+                fake_texture->Release(); // we release the fake texture
             }
         }
         else {
@@ -233,8 +227,6 @@ HRESULT APIENTRY uMod_IDirect3DCubeTexture9::UnlockRect(D3DCUBEMAP_FACES FaceTyp
     return m_D3Dtex->UnlockRect(FaceType, Level);
 }
 
-
-
 HashType uMod_IDirect3DCubeTexture9::GetHash() const
 {
     if (FAKE) {
@@ -251,7 +243,7 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
 
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
-        Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetLevelDesc \n");
+        Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetLevelDesc \n");
         return 0;
     }
 
@@ -259,20 +251,20 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
 
     if (pTexture->LockRect(D3DCUBEMAP_FACE_POSITIVE_X, 0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK)
     {
-        Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 1\n");
+        Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &pResolvedSurface) != D3D_OK) {
-            Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetSurfaceLevel\n");
+            Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetSurfaceLevel\n");
             return 0;
         }
         if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
-            Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 2\n");
+            Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 2\n");
             return 0;
         }
     }
 
-    const int size = (GetBitsFromFormat(desc.Format) * desc.Width * desc.Height) / 8;
-    const auto hash = GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    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
 
     // Only release surfaces after we're finished with d3dlr
     if (pResolvedSurface != nullptr) {

source/uMod_IDirect3DDevice9.cpp

@@ -1,4 +1,5 @@
 #include "Main.h"
+import TextureClient;
 
 #ifndef RETURN_QueryInterface
 #define RETURN_QueryInterface 0x01000000L
@@ -8,128 +9,15 @@
 #define PRE_MESSAGE "uMod_IDirect3DDevice9"
 #endif
 
-
-int uMod_IDirect3DDevice9::CreateSingleTexture()
-{
-    if (SingleTexture != nullptr && SingleVolumeTexture != nullptr && SingleCubeTexture != nullptr && TextureColour == uMod_Client->TextureColour) {
-        return RETURN_OK;
-    }
-    TextureColour = uMod_Client->TextureColour;
-    if (SingleTexture == nullptr) //create texture
-    {
-        if (D3D_OK != CreateTexture(8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DTexture9**)&SingleTexture, nullptr)) {
-            Message(PRE_MESSAGE "::CreateSingleTexture(): CreateTexture Failed\n");
-            SingleTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        LastCreatedTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
-        SingleTexture->FAKE = true; //this is no texture created from by game
-    }
-
-    {
-        D3DLOCKED_RECT d3dlr;
-        IDirect3DTexture9* pD3Dtex = SingleTexture->m_D3Dtex;
-
-        if (D3D_OK != pD3Dtex->LockRect(0, &d3dlr, nullptr, 0)) {
-            Message(PRE_MESSAGE "::CreateSingleTexture(): LockRect Failed\n");
-            SingleTexture->Release();
-            SingleTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
-
-        for (int i = 0; i < 8 * 8; i++) {
-            pDst[i] = TextureColour;
-        }
-        pD3Dtex->UnlockRect(0);
-    }
-
-    if (SingleVolumeTexture == nullptr) //create texture
-    {
-        if (D3D_OK != CreateVolumeTexture(8, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DVolumeTexture9**)&SingleVolumeTexture, nullptr)) {
-            Message(PRE_MESSAGE "::CreateSingleTexture(): CreateVolumeTexture Failed\n");
-            SingleVolumeTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        LastCreatedVolumeTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
-        SingleVolumeTexture->FAKE = true; //this is no texture created from by game
-    }
-
-    {
-        D3DLOCKED_BOX d3dlr;
-        IDirect3DVolumeTexture9* pD3Dtex = SingleVolumeTexture->m_D3Dtex;
-        //LockBox)(UINT Level, D3DLOCKED_BOX *pLockedVolume, CONST D3DBOX *pBox,
-        if (D3D_OK != pD3Dtex->LockBox(0, &d3dlr, nullptr, 0)) {
-            Message(PRE_MESSAGE "::CreateSingleTexture(): LockBox Failed\n");
-            SingleVolumeTexture->Release();
-            SingleVolumeTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
-
-        for (int i = 0; i < 8 * 8 * 8; i++) {
-            pDst[i] = TextureColour;
-        }
-        pD3Dtex->UnlockBox(0);
-    }
-    if (SingleCubeTexture == nullptr) //create texture
-    {
-        if (D3D_OK != CreateCubeTexture(8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DCubeTexture9**)&SingleCubeTexture, nullptr)) {
-            Message(PRE_MESSAGE "::CreateSingleTexture(): CreateCubeTexture Failed\n");
-            SingleCubeTexture = nullptr;
-            return RETURN_TEXTURE_NOT_LOADED;
-        }
-        LastCreatedCubeTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
-        SingleCubeTexture->FAKE = true; //this is no texture created from by game
-    }
-
-    {
-        D3DLOCKED_RECT d3dlr;
-        IDirect3DCubeTexture9* pD3Dtex = SingleCubeTexture->m_D3Dtex;
-
-        for (int c = 0; c < 6; c++) {
-            if (D3D_OK != pD3Dtex->LockRect(static_cast<D3DCUBEMAP_FACES>(c), 0, &d3dlr, nullptr, 0)) {
-                Message(PRE_MESSAGE "::CreateSingleTexture(): LockRect (Cube) Failed\n");
-                SingleCubeTexture->Release();
-                SingleCubeTexture = nullptr;
-                return RETURN_TEXTURE_NOT_LOADED;
-            }
-            const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
-
-            for (int i = 0; i < 8 * 8; i++) {
-                pDst[i] = TextureColour;
-            }
-            pD3Dtex->UnlockRect(static_cast<D3DCUBEMAP_FACES>(c), 0);
-        }
-    }
-
-    return RETURN_OK;
-}
-
 uMod_IDirect3DDevice9::uMod_IDirect3DDevice9(IDirect3DDevice9* pOriginal, int back_buffer_count)
 {
     Message(PRE_MESSAGE "::" PRE_MESSAGE " (%p): %p\n", pOriginal, this);
 
     BackBufferCount = back_buffer_count;
-    NormalRendering = true;
 
     uMod_Client = new TextureClient(this); //get a new texture client for this device
     uMod_Client->Initialize();
-
-    LastCreatedTexture = nullptr;
-    LastCreatedVolumeTexture = nullptr;
-    LastCreatedCubeTexture = nullptr;
     m_pIDirect3DDevice9 = pOriginal; // store the pointer to original object
-    TextureColour = D3DCOLOR_ARGB(255, 0, 255, 0);
-
-    CounterSaveSingleTexture = -20;
-
-    SingleTextureMod = 0;
-    SingleTexture = nullptr;
-    SingleVolumeTexture = nullptr;
-    SingleCubeTexture = nullptr;
-    OSD_Font = nullptr;
-    uMod_Reference = 1;
 }
 
 uMod_IDirect3DDevice9::~uMod_IDirect3DDevice9()
@@ -172,23 +60,8 @@ ULONG uMod_IDirect3DDevice9::Release()
         // we must not release the fake textures, cause they are released if the target textures are released
         // and the target textures are released by the game.
 
-        if (SingleTexture != nullptr) {
-            SingleTexture->Release(); //this is the only texture we must release by ourself
-        }
-        if (SingleVolumeTexture != nullptr) {
-            SingleVolumeTexture->Release(); //this is the only texture we must release by ourself
-        }
-        if (SingleCubeTexture != nullptr) {
-            SingleCubeTexture->Release(); //this is the only texture we must release by ourself
-        }
-        if (OSD_Font != nullptr) {
-            OSD_Font->Release();
-        }
-
         delete uMod_Client; //must be deleted at the end, because other releases might call a function of this object
         uMod_Client = nullptr;
-        SingleTexture = nullptr;
-        OSD_Font = nullptr;
     }
 
     const ULONG count = m_pIDirect3DDevice9->Release();
@@ -271,10 +144,6 @@ UINT uMod_IDirect3DDevice9::GetNumberOfSwapChains()
 
 HRESULT uMod_IDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters)
 {
-    if (OSD_Font != nullptr) {
-        OSD_Font->Release();
-        OSD_Font = nullptr;
-    } //the game will crashes if the font is not released before the game is minimized!
     return m_pIDirect3DDevice9->Reset(pPresentationParameters);
 }
 
@@ -311,23 +180,18 @@ void uMod_IDirect3DDevice9::GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp)
 HRESULT uMod_IDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle)
 {
     //create real texture
-    //Message("uMod_IDirect3DDevice9::CreateTexture()\n");
+    Message("uMod_IDirect3DDevice9::CreateTexture()\n");
     const HRESULT ret = m_pIDirect3DDevice9->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
     if (ret != D3D_OK) {
         return ret;
     }
 
-    //create fake texture
     const auto texture = new uMod_IDirect3DTexture9(ppTexture, this);
-    if (texture) {
-        *ppTexture = texture;
-    }
+    *ppTexture = texture;
 
-    if (LastCreatedTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
+    if (LastCreatedTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
     {
-        if (uMod_Client != nullptr) {
-            uMod_Client->AddTexture(LastCreatedTexture);
-        }
+        uMod_Client->AddTexture(LastCreatedTexture);
     }
     LastCreatedTexture = texture;
     return ret;
@@ -336,7 +200,7 @@ HRESULT uMod_IDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Level
 HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle)
 {
     //create real texture
-    //Message("uMod_IDirect3DDevice9::CreateVolumeTexture()\n");
+    Message("uMod_IDirect3DDevice9::CreateVolumeTexture()\n");
     const HRESULT ret = m_pIDirect3DDevice9->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture, pSharedHandle);
     if (ret != D3D_OK) {
         return ret;
@@ -344,15 +208,11 @@ HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT
 
     //create fake texture
     const auto texture = new uMod_IDirect3DVolumeTexture9(ppVolumeTexture, this);
-    if (texture) {
-        *ppVolumeTexture = texture;
-    }
+    *ppVolumeTexture = texture;
 
-    if (LastCreatedVolumeTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
+    if (LastCreatedVolumeTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
     {
-        if (uMod_Client != nullptr) {
-            uMod_Client->AddTexture(LastCreatedVolumeTexture);
-        }
+        uMod_Client->AddTexture(LastCreatedVolumeTexture);
     }
     LastCreatedVolumeTexture = texture;
     return ret;
@@ -361,7 +221,7 @@ HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT
 HRESULT uMod_IDirect3DDevice9::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle)
 {
     //create real texture
-    //Message("uMod_IDirect3DDevice9::CreateCubeTexture()\n");
+    Message("uMod_IDirect3DDevice9::CreateCubeTexture()\n");
     const HRESULT ret = m_pIDirect3DDevice9->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture, pSharedHandle);
     if (ret != D3D_OK) {
         return ret;
@@ -369,15 +229,11 @@ HRESULT uMod_IDirect3DDevice9::CreateCubeTexture(UINT EdgeLength, UINT Levels, D
 
     //create fake texture
     const auto texture = new uMod_IDirect3DCubeTexture9(ppCubeTexture, this);
-    if (texture) {
-        *ppCubeTexture = texture;
-    }
+    *ppCubeTexture = texture;
 
-    if (LastCreatedCubeTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
+    if (LastCreatedCubeTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
     {
-        if (uMod_Client != nullptr) {
-            uMod_Client->AddTexture(LastCreatedCubeTexture);
-        }
+        uMod_Client->AddTexture(LastCreatedCubeTexture);
     }
     LastCreatedCubeTexture = texture;
     return ret;

source/uMod_IDirect3DTexture9.cpp

@@ -1,5 +1,8 @@
 #include "Main.h"
 
+import TextureFunction;
+import TextureClient;
+
 //this function yields for the non switched texture object
 HRESULT APIENTRY uMod_IDirect3DTexture9::QueryInterface(REFIID riid, void** ppvObj)
 {
@@ -62,16 +65,7 @@ ULONG APIENTRY uMod_IDirect3DTexture9::Release()
             if (count == 0) //if texture is released we switch the textures back
             {
                 UnswitchTextures(this);
-                if (ret == 0x01000000L) {
-                    if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
-                else {
-                    if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
+                fake_texture->Release(); // we release the fake texture
             }
         }
         else {
@@ -252,7 +246,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
 
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
-        Message("uMod_IDirect3DTexture9::GetHash() Failed: GetLevelDesc \n");
+        Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetLevelDesc \n");
         return 0;
     }
 
@@ -265,7 +259,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
 
         IDirect3DSurface9* pSurfaceLevel_orig = nullptr;
         if (pTexture->GetSurfaceLevel(0, &pSurfaceLevel_orig) != D3D_OK) {
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel 1  (D3DPOOL_DEFAULT)\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel 1  (D3DPOOL_DEFAULT)\n");
             return 0;
         }
 
@@ -273,12 +267,12 @@ HashType uMod_IDirect3DTexture9::GetHash() const
             //Message("uMod_IDirect3DTexture9::GetHash() MultiSampleType\n");
             if (D3D_OK != m_D3Ddev->CreateRenderTarget(desc.Width, desc.Height, desc.Format, D3DMULTISAMPLE_NONE, 0, FALSE, &pResolvedSurface, nullptr)) {
                 pSurfaceLevel_orig->Release();
-                Message("uMod_IDirect3DTexture9::GetHash() Failed: CreateRenderTarget  (D3DPOOL_DEFAULT)\n");
+                Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateRenderTarget  (D3DPOOL_DEFAULT)\n");
                 return 0;
             }
             if (D3D_OK != m_D3Ddev->StretchRect(pSurfaceLevel_orig, nullptr, pResolvedSurface, nullptr, D3DTEXF_NONE)) {
                 pSurfaceLevel_orig->Release();
-                Message("uMod_IDirect3DTexture9::GetHash() Failed: StretchRect  (D3DPOOL_DEFAULT)\n");
+                Warning("uMod_IDirect3DTexture9::GetHash() Failed: StretchRect  (D3DPOOL_DEFAULT)\n");
                 return 0;
             }
 
@@ -290,7 +284,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
             if (pResolvedSurface != nullptr) {
                 pResolvedSurface->Release();
             }
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: CreateOffscreenPlainSurface (D3DPOOL_DEFAULT)\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateOffscreenPlainSurface (D3DPOOL_DEFAULT)\n");
             return 0;
         }
 
@@ -300,7 +294,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
                 pResolvedSurface->Release();
             }
             pOffscreenSurface->Release();
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: GetRenderTargetData (D3DPOOL_DEFAULT)\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetRenderTargetData (D3DPOOL_DEFAULT)\n");
             return 0;
         }
         pSurfaceLevel_orig->Release();
@@ -310,25 +304,25 @@ HashType uMod_IDirect3DTexture9::GetHash() const
                 pResolvedSurface->Release();
             }
             pOffscreenSurface->Release();
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect (D3DPOOL_DEFAULT)\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect (D3DPOOL_DEFAULT)\n");
             return 0;
         }
     }
     else if (pTexture->LockRect(0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
-        Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 1\n");
+        Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetSurfaceLevel(0, &pResolvedSurface) != D3D_OK) {
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel\n");
             return 0;
         }
         if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
-            Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 2\n");
+            Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 2\n");
             return 0;
         }
     }
 
-    const int size = (GetBitsFromFormat(desc.Format) * desc.Width * desc.Height) / 8;
-    const auto hash = GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    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
 
     // Only release surfaces after we're finished with d3dlr
     if (pOffscreenSurface != nullptr) {

source/uMod_IDirect3DVolumeTexture9.cpp

@@ -1,4 +1,6 @@
 #include "Main.h"
+import TextureFunction;
+import TextureClient;
 
 HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::QueryInterface(REFIID riid, void** ppvObj)
 {
@@ -61,16 +63,7 @@ ULONG APIENTRY uMod_IDirect3DVolumeTexture9::Release()
             if (count == 0) //if texture is released we switch the textures back
             {
                 UnswitchTextures(this);
-                if (ret == 0x01000000L) {
-                    if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleVolumeTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
-                else {
-                    if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleVolumeTexture() != fake_texture) {
-                        fake_texture->Release(); // we release the fake texture
-                    }
-                }
+                fake_texture->Release(); // we release the fake texture
             }
         }
         else {
@@ -187,8 +180,6 @@ void APIENTRY uMod_IDirect3DVolumeTexture9::GenerateMipSubLevels()
     m_D3Dtex->GenerateMipSubLevels();
 }
 
-
-
 //this function yields for the non switched texture object
 HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::AddDirtyBox(CONST D3DBOX* pDirtyBox)
 {
@@ -234,7 +225,6 @@ HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::UnlockBox(UINT Level)
     return m_D3Dtex->UnlockBox(Level);
 }
 
-
 HashType uMod_IDirect3DVolumeTexture9::GetHash() const
 {
     if (FAKE) {
@@ -251,28 +241,26 @@ HashType uMod_IDirect3DVolumeTexture9::GetHash() const
 
     if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
     {
-        Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetLevelDesc \n");
+        Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetLevelDesc \n");
         return 0;
     }
 
     Message("uMod_IDirect3DVolumeTexture9::GetHash() (%d %d %d) %d\n", desc.Width, desc.Height, desc.Depth, desc.Format);
     if (pTexture->LockBox(0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
-        Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 1\n");
+        Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 1\n");
         if (pTexture->GetVolumeLevel(0, &pResolvedSurface) != D3D_OK) {
-            Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetSurfaceLevel\n");
+            Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetSurfaceLevel\n");
             return 0;
         }
         if (pResolvedSurface->LockBox(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
             pResolvedSurface->Release();
-            Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 2\n");
+            Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 2\n");
             return 0;
         }
     }
 
-
-
-    const int size = (GetBitsFromFormat(desc.Format) * desc.Width * desc.Height * desc.Depth) / 8;
-    const auto hash = GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture
+    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
 
     // Only release surfaces after we're finished with d3dlr
     if (pResolvedSurface != nullptr) {