REFramework.cpp

#include <chrono>
#include <filesystem>
#include <fstream>

#include <windows.h>
#include <ShlObj.h>

#include <initguid.h>
#include <Dbt.h>

#include <spdlog/sinks/basic_file_sink.h>

// minhook, used for AllocateBuffer
extern "C" {
#include <../buffer.h>
};

#include <imgui.h>
#include <imgui_freetype.h>
#include <ImGuizmo.h>
#include <imnodes.h>
#include "re2-imgui/af_faprolight.hpp"
#include "re2-imgui/font_robotomedium.hpp"
#include "re2-imgui/imgui_impl_dx11.h"
#include "re2-imgui/imgui_impl_dx12.h"
#include "re2-imgui/imgui_impl_win32.h"

#include "utility/Module.hpp"
#include "utility/Patch.hpp"
#include "utility/Scan.hpp"
#include "utility/Thread.hpp"

#include "Mods.hpp"
#include "mods/LooseFileLoader.hpp"
#include "mods/PluginLoader.hpp"
#include "mods/VR.hpp"
#include "sdk/REGlobals.hpp"
#include "sdk/Application.hpp"
#include "sdk/SDK.hpp"

#include "ExceptionHandler.hpp"
#include "LicenseStrings.hpp"
#include "mods/REFrameworkConfig.hpp"
#include "mods/IntegrityCheckBypass.hpp"
#include "CommitHash.autogenerated"
#include "REFramework.hpp"

namespace fs = std::filesystem;
using namespace std::literals;

extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
DEFINE_GUID(GUID_DEVINTERFACE_HID, 0x4D1E55B2L, 0xF16F, 0x11CF, 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30);
DEFINE_GUID(XUSB_INTERFACE_CLASS_GUID, 0xEC87F1E3, 0xC13B, 0x4100, 0xB5, 0xF7, 0x8B, 0x84, 0xD5, 0x42, 0x60, 0xCB);

std::unique_ptr<REFramework> g_framework{};

void REFramework::hook_monitor() {
    if (m_do_not_hook_d3d_count.load() > 0) {
        // Wait until nothing important is happening
        m_last_present_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);
        m_last_chance_time = std::chrono::steady_clock::now() + std::chrono::seconds(1);
        m_has_last_chance = true;
        return;
    }

    if (!m_hook_monitor_mutex.try_lock()) {
        // If this happens then we can assume execution is going as planned
        // so we can just reset the times so we dont break something
        m_last_present_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);
        m_last_chance_time = std::chrono::steady_clock::now() + std::chrono::seconds(1);
        m_has_last_chance = true;
        return;
    }

    // Take ownership of the mutex with adopt_lock
    std::lock_guard _{ m_hook_monitor_mutex, std::adopt_lock };

    if (g_framework == nullptr) {
        return;
    }

    const auto now = std::chrono::steady_clock::now();

    auto& d3d11 = get_d3d11_hook();
    auto& d3d12 = get_d3d12_hook();

    const auto renderer_type = get_renderer_type();

    if (d3d11 == nullptr || d3d12 == nullptr 
        || (renderer_type == REFramework::RendererType::D3D11 && d3d11 != nullptr && !d3d11->is_inside_present()) 
        || (renderer_type == REFramework::RendererType::D3D12 && d3d12 != nullptr && !d3d12->is_inside_present())) 
    {
        // check if present time is more than 5 seconds ago
        if (now - m_last_present_time > std::chrono::seconds(5)) {
            if (m_has_last_chance) {
                // the purpose of this is to make sure that the game is not frozen
                // e.g. if we are debugging the game, so we don't rehook anything on accident
                m_has_last_chance = false;
                m_last_chance_time = now;

                spdlog::info("Last chance encountered for hooking");
            }

            if (!m_has_last_chance && now - m_last_chance_time > std::chrono::seconds(1)) {
                spdlog::info("Sending rehook request for D3D");

                // hook_d3d12 always gets called first.
                if (m_is_d3d11) {
                    hook_d3d11();
                } else {
                    hook_d3d12();
                }

                // so we don't immediately go and hook it again
                // add some additional time to it to give it some leeway
                m_last_present_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);
                m_last_message_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);
                m_last_chance_time = std::chrono::steady_clock::now() + std::chrono::seconds(1);
                m_has_last_chance = true;
            }
        } else {
            m_last_chance_time = std::chrono::steady_clock::now();
            m_has_last_chance = true;
        }

        if (m_initialized && m_wnd != 0 && now - m_last_message_time > std::chrono::seconds(5)) {
            if (m_windows_message_hook != nullptr && m_windows_message_hook->is_hook_intact()) {
                spdlog::info("Windows message hook is still intact, ignoring...");
                m_last_message_time = now;
                m_last_sendmessage_time = now;
                m_sent_message = false;
                return;
            }

            // send dummy message to window to check if our hook is still intact
            if (!m_sent_message) {
                spdlog::info("Sending initial message hook test");

                auto proc = (WNDPROC)GetWindowLongPtr(m_wnd, GWLP_WNDPROC);

                if (proc != nullptr) {
                    const auto ret = CallWindowProc(proc, m_wnd, WM_NULL, 0, 0);

                    spdlog::info("Hook test message sent");
                }

                m_last_sendmessage_time = std::chrono::steady_clock::now();
                m_sent_message = true;
            } else if (now - m_last_sendmessage_time > std::chrono::seconds(1)) {
                spdlog::info("Sending reinitialization request for message hook");

                // if we don't get a message for 5 seconds, assume the hook is broken
                //m_initialized = false; // causes the hook to be re-initialized next frame
                m_message_hook_requested = true;
                m_last_message_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);
                m_last_present_time = std::chrono::steady_clock::now() + std::chrono::seconds(5);

                m_sent_message = false;
            }
        } else {
            m_sent_message = false;
        }
    }
}

typedef struct _LDR_DLL_UNLOADED_NOTIFICATION_DATA {
    ULONG Flags;                    //Reserved.
    PCUNICODE_STRING FullDllName;   //The full path name of the DLL module.
    PCUNICODE_STRING BaseDllName;   //The base file name of the DLL module.
    PVOID DllBase;                  //A pointer to the base address for the DLL in memory.
    ULONG SizeOfImage;              //The size of the DLL image, in bytes.
} LDR_DLL_UNLOADED_NOTIFICATION_DATA, *PLDR_DLL_UNLOADED_NOTIFICATION_DATA;

typedef struct _LDR_DLL_LOADED_NOTIFICATION_DATA {
    ULONG Flags;                    //Reserved.
    PCUNICODE_STRING FullDllName;   //The full path name of the DLL module.
    PCUNICODE_STRING BaseDllName;   //The base file name of the DLL module.
    PVOID DllBase;                  //A pointer to the base address for the DLL in memory.
    ULONG SizeOfImage;              //The size of the DLL image, in bytes.
} LDR_DLL_LOADED_NOTIFICATION_DATA, *PLDR_DLL_LOADED_NOTIFICATION_DATA;

typedef union _LDR_DLL_NOTIFICATION_DATA {
    LDR_DLL_LOADED_NOTIFICATION_DATA Loaded;
    LDR_DLL_UNLOADED_NOTIFICATION_DATA Unloaded;
} LDR_DLL_NOTIFICATION_DATA, *PLDR_DLL_NOTIFICATION_DATA;

using PLDR_DLL_NOTIFICATION_FUNCTION = void (*)(
  ULONG                       NotificationReason,
  PLDR_DLL_NOTIFICATION_DATA NotificationData,
  PVOID                       Context
);

using LdrRegisterDllNotification_t = NTSTATUS (*) (
    ULONG                          Flags,
    PLDR_DLL_NOTIFICATION_FUNCTION NotificationFunction,
    PVOID                          Context,
    PVOID                          *Cookie
);

#define LDR_DLL_NOTIFICATION_REASON_LOADED 1
#define LDR_DLL_NOTIFICATION_REASON_UNLOADED 2

std::optional<std::filesystem::path> g_current_game_path{};
bool g_success_made_ldr_notification{false};

void CALLBACK ldr_notification_callback(
    ULONG                       NotificationReason,
    PLDR_DLL_NOTIFICATION_DATA NotificationData,
    PVOID                       Context
) 
try {
    // From what I can tell, the PEB entries get filled in by the time this is called
    // so we're good.
    if (NotificationReason == LDR_DLL_NOTIFICATION_REASON_LOADED) {
        if (NotificationData->Loaded.BaseDllName != nullptr && NotificationData->Loaded.BaseDllName->Buffer != nullptr) {
            std::wstring base_dll_name = NotificationData->Loaded.BaseDllName->Buffer;
            std::wstring lower_base_dll_name = base_dll_name;
            std::transform(lower_base_dll_name.begin(), lower_base_dll_name.end(), lower_base_dll_name.begin(), ::towlower);
            spdlog::info("LdrRegisterDllNotification: Loaded: {}", utility::narrow(base_dll_name));

            if (lower_base_dll_name.find(L"sl.dlss_g.dll") != std::wstring::npos) {
                spdlog::info("LdrRegisterDllNotification: Detected DLSS DLL loaded");

                D3D12Hook::hook_streamline((HMODULE)NotificationData->Loaded.DllBase);
            }
        }

        if (g_current_game_path && NotificationData->Loaded.FullDllName != nullptr && NotificationData->Loaded.FullDllName->Buffer != nullptr) {
            std::wstring full_dll_name = NotificationData->Loaded.FullDllName->Buffer;
            std::filesystem::path full_dll_path = full_dll_name;

            if (full_dll_path.parent_path() == *g_current_game_path) {
                spdlog::info("LdrRegisterDllNotification: DLL loaded from game directory: {}", utility::narrow(full_dll_name));

#if defined(DD2) || defined(MHRISE) || TDB_VER >= 74
                utility::spoof_module_paths_in_exe_dir();
#endif
            }
        } else {
            spdlog::info("LdrRegisterDllNotification: DLL loaded from unknown location");
        }
    }
} catch (const std::exception& e) {
    spdlog::error("ldr_notification_callback: Exception occurred: {}", e.what());
} catch(...) {
    spdlog::error("ldr_notification_callback: Unknown exception occurred");
}

REFramework::REFramework(HMODULE reframework_module)
    : m_game_module{GetModuleHandle(0)}
    , m_logger{spdlog::basic_logger_mt("REFramework", (get_persistent_dir("re2_framework_log.txt")).string(), true)}
    {

    s_reframework_module = reframework_module;

    std::scoped_lock __{m_startup_mutex};

    spdlog::set_default_logger(m_logger);
    spdlog::flush_on(spdlog::level::info);

    if (s_fallback_appdata) {
        spdlog::warn("Failed to write to current directory, falling back to appdata folder");
    }

    spdlog::info("REFramework entry");

    spdlog::info("Commit hash: {}", REF_COMMIT_HASH);
    spdlog::info("Tag: {}", REF_TAG);
    spdlog::info("Commits past tag: {}", REF_COMMITS_PAST_TAG);
    spdlog::info("Branch: {}", REF_BRANCH);
    spdlog::info("Total commits: {}", REF_TOTAL_COMMITS);
    spdlog::info("Build date: {}", REF_BUILD_DATE);
    spdlog::info("Build time: {}", REF_BUILD_TIME);
    spdlog::info("Game name: {}", REFramework::get_game_name());

    const auto module_size = *utility::get_module_size(m_game_module);

    spdlog::info("Game Module Addr: {:x}", (uintptr_t)m_game_module);
    spdlog::info("Game Module Size: {:x}", module_size);

    if (auto current_game_path = utility::get_module_pathw(m_game_module); current_game_path.has_value()) {
        g_current_game_path = *current_game_path;
        g_current_game_path = g_current_game_path->parent_path();
        spdlog::info("Current game path: {}", utility::narrow(g_current_game_path->c_str()));
    }

    // preallocate some memory for minhook to mitigate failures (temporarily at least... this should in theory fail when too many hooks are made)
    // but, 64 slots should be enough for now. 
    // so... TODO: modify minhook to use absolute jumps when failing to allocate memory nearby
    const auto halfway_module = (uintptr_t)m_game_module + (module_size / 2);
    const auto pre_allocated_buffer = (uintptr_t)AllocateBuffer((LPVOID)halfway_module); // minhook function
    spdlog::info("Preallocated buffer: {:x}", pre_allocated_buffer);

    IntegrityCheckBypass::fix_virtual_protect();

    IMGUI_CHECKVERSION();
    ImGui::CreateContext();

#ifdef DEBUG
    spdlog::set_level(spdlog::level::debug);
#endif

    // Create the typedef for RtlGetVersion
    typedef LONG (*RtlGetVersionFunc)(PRTL_OSVERSIONINFOW);

    const auto ntdll = GetModuleHandle("ntdll.dll");

    if (ntdll != nullptr) {
        // Manually get RtlGetVersion
        auto rtl_get_version = (RtlGetVersionFunc)GetProcAddress(ntdll, "RtlGetVersion");

        if (rtl_get_version != nullptr) {
            spdlog::info("Getting OS version information...");

            // Create an initial log that prints out the user's Windows OS version information
            // With the major and minor version numbers
            // Using RtlGetVersion()
            OSVERSIONINFOW os_version_info{};
            ZeroMemory(&os_version_info, sizeof(OSVERSIONINFOW));
            os_version_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
            os_version_info.dwMajorVersion = 0;
            os_version_info.dwMinorVersion = 0;
            os_version_info.dwBuildNumber = 0;
            os_version_info.dwPlatformId = 0;

            if (rtl_get_version(&os_version_info) != 0) {
                spdlog::info("RtlGetVersion() failed");
            } else {
                // Log the Windows version information
                spdlog::info("OS Version Information");
                spdlog::info("\tMajor Version: {}", os_version_info.dwMajorVersion);
                spdlog::info("\tMinor Version: {}", os_version_info.dwMinorVersion);
                spdlog::info("\tBuild Number: {}", os_version_info.dwBuildNumber);
                spdlog::info("\tPlatform Id: {}", os_version_info.dwPlatformId);

                spdlog::info("Disclaimer: REFramework does not send this information to the developers or any other third party.");
                spdlog::info("This information is only used to help with the development of REFramework.");
            }
        } else {
            spdlog::info("RtlGetVersion() not found");
        }

        // Do this at least once before setting up our callback.
#if defined(DD2) || defined(MHRISE) || TDB_VER >= 74
        // Pre-emptively copy all DLL files in the current game directory into our _storage_ directory.
        if (g_current_game_path.has_value()) {
            const auto dest_path = *g_current_game_path / "_storage_";
            fs::create_directories(dest_path);

            if (std::filesystem::exists(dest_path)) try {
                std::error_code directory_ec{};
                // Locate all DLL files in the current game directory
                for (const auto& entry : fs::directory_iterator(*g_current_game_path, directory_ec)) try {
                    const auto entry_path = entry.path();
                    
                    if (entry.is_regular_file() && entry_path.extension() == ".dll") {
                        spdlog::info("Copying DLL file: {}", entry_path.filename().string());
                        spdlog::info(" Full path: {}", entry_path.string());
                        const auto final_dest = dest_path / entry_path.filename().string();
                        spdlog::info(" Destination: {}", final_dest.string());
                        std::error_code ec{};
                        fs::copy_file(entry_path, final_dest, fs::copy_options::overwrite_existing, ec);

                        // check if error occurred
                        if (ec) {
                            spdlog::error("Failed to copy DLL file: {}", ec.message());
                        }

                        ec.clear();
                    }
                } catch (const std::filesystem::filesystem_error& e) {
                    spdlog::error("Failed to copy DLL file: {}", e.what());
                } catch (const std::exception& e) {
                    spdlog::error("Failed to copy DLL file: {}", e.what());
                } catch(...) {
                    spdlog::error("Failed to copy DLL file: unknown exception occurred");
                }

                if (directory_ec) {
                    spdlog::error("An error occurred while traversing the game directory: {}", directory_ec.message());
                }

                // Copy the D3D12/D3D12Core.dll file from the current game directory into our _storage_ directory with the same subdirectory structure.
                const auto d3d12_path = *g_current_game_path / "D3D12" / "D3D12Core.dll";

                if (std::filesystem::exists(d3d12_path)) try {
                    spdlog::info("Copying D3D12Core.dll file");
                    fs::create_directories(dest_path / "D3D12");

                    if (std::filesystem::exists(d3d12_path)) {
                        spdlog::info("Copying D3D12Core.dll file");
                        std::error_code ec{};
                        fs::copy_file(d3d12_path, dest_path / "D3D12" / "D3D12Core.dll", fs::copy_options::overwrite_existing, ec);

                        if (ec) {
                            spdlog::error("Failed to copy D3D12Core.dll file: {}", ec.message());
                        }

                        ec.clear();
                    }
                } catch (const std::filesystem::filesystem_error& e) {
                    spdlog::error("Failed to copy D3D12Core.dll file: {}", e.what());
                } catch (const std::exception& e) {
                    spdlog::error("Failed to copy D3D12Core.dll file: {}", e.what());
                } catch(...) {
                    spdlog::error("Failed to copy D3D12Core.dll file: unknown exception occurred");
                }
            } catch (const std::filesystem::filesystem_error& e) {
                spdlog::error("An error occurred while copying DLL files: {}", e.what());
            } catch (const std::exception& e) {
                spdlog::error("An error occurred while copying DLL files: {}", e.what());
            } catch(...) {
                spdlog::error("An error occurred while copying DLL files: unknown exception occurred");
            } else {
                spdlog::error("Failed to create storage directory");
            }
        }

        utility::spoof_module_paths_in_exe_dir();
#endif

        // Register our LdrRegisterDllNotification callback
        spdlog::info("Registering LdrRegisterDllNotification callback...");
        const auto ldr_register_dll_notification = (LdrRegisterDllNotification_t)GetProcAddress(ntdll, "LdrRegisterDllNotification");

        if (ldr_register_dll_notification != nullptr) {
            PVOID cookie = nullptr;
            g_success_made_ldr_notification = NT_SUCCESS(ldr_register_dll_notification(0, ldr_notification_callback, nullptr, &cookie));

            if (g_success_made_ldr_notification) {
                spdlog::info("LdrRegisterDllNotification callback registered successfully");
            } else {
                spdlog::info("LdrRegisterDllNotification callback failed to register");
            }
        } else {
            spdlog::info("LdrRegisterDllNotification not found");
        }
    } else {
        spdlog::info("ntdll.dll not found");
    }

    // wait for the game to load (WTF MHRISE??)
    // once this is done, we can assume the process is unpacked.
#if defined (REENGINE_PACKED)
    auto now = std::chrono::steady_clock::now();
    std::chrono::steady_clock::time_point next_log = now;

    while (GetModuleHandleA("d3d12.dll") == nullptr) {
        now = std::chrono::steady_clock::now();
        if (now >= next_log) {
            spdlog::info("[REFramework] Waiting for D3D12...");
            next_log = now + 1s;
        }
        Sleep(50);
    }

    while (LoadLibraryA("d3d12.dll") == nullptr) {
        if (now >= next_log) {
            spdlog::info("[REFramework] Waiting for D3D12...");
            next_log = now + 1s;
        }
    }

    spdlog::info("D3D12 loaded");
#endif

#if defined(MHRISE) || defined(DD2) || TDB_VER >= 74
    utility::load_module_from_current_directory(L"openvr_api.dll");
    utility::load_module_from_current_directory(L"openxr_loader.dll");
    LoadLibraryA("dxgi.dll");
    LoadLibraryA("d3d11.dll");

    if (!g_success_made_ldr_notification) {
        utility::spoof_module_paths_in_exe_dir();
    }
#endif

#if defined(RE8)
    auto startup_lookup_thread = std::make_unique<std::thread>([this]() {
        // Fixes a crash on some machines when starting the game
        // This one has nothing to do with integrity checks
        // it has something to do with the Agility SDK and pipeline state.
        uint32_t times_searched = 0;

        auto startup_patch_addr = utility::scan(m_game_module, "40 53 57 48 83 ec 28 48 83 b9 ? ? ? ? 00");

        while (!startup_patch_addr) {
            startup_patch_addr = utility::scan(m_game_module, "40 53 57 48 83 ec 28 48 83 b9 ? ? ? ? 00");

            if (times_searched++ > 10) {
                spdlog::error("Failed to find startup patch address");
                return;
            }
        }

        if (startup_patch_addr) {
            spdlog::info("Found startup patch at {:x}", *startup_patch_addr);
            static auto permanent_patch = Patch::create(*startup_patch_addr, {0xC3});
        } else {
            spdlog::info("Couldn't find RE8 crash fix patch location!");
        }
    });
    startup_lookup_thread->detach();
#endif

#if defined(REENGINE_AT)
    utility::ThreadSuspender suspender{};
    IntegrityCheckBypass::ignore_application_entries();

#if defined(RE8) || defined(RE4) || defined(SF6)
    // Also done on RE4 because some of the scans are the same.
    IntegrityCheckBypass::immediate_patch_re8();
#endif

#if defined(RE4) || defined(SF6)
    // Fixes new code added in RE4 only.
    IntegrityCheckBypass::immediate_patch_re4();
#endif

#if defined(DD2) || TDB_VER >= 74
    // Fixes new code added in DD2 only. Maybe >= TDB73 too. Probably will change.
    IntegrityCheckBypass::immediate_patch_dd2();
#endif

    // Seen in SF6
    IntegrityCheckBypass::remove_stack_destroyer();
    suspender.resume();
#endif

    // Load the plugins early right after executable unpacking
    PluginLoader::get()->early_init();

    // Wait for TDB and render device to be initialized before allowing D3D hooking
    const auto start_time = std::chrono::high_resolution_clock::now();

    while (true) {
        try {
            if (sdk::VM::get() != nullptr) {
                break;
            }
        } catch(...) {
        }

        if (std::chrono::high_resolution_clock::now() - start_time > std::chrono::seconds(30)) {
            spdlog::error("Timed out waiting for VM to initialize.");
            throw std::runtime_error("Timed out waiting for VM to initialize.");
        }

        //std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::this_thread::yield();
    }

    spdlog::info("VM initialized, waiting for renderer to initialize...");
    sdk::RETypeDefinition* renderer_t = nullptr;
    sdk::renderer::Renderer* renderer = nullptr;
    bool found_renderer = false;
    bool renderer_has_render_frame_fn = false;

    if (sdk::RETypeDB::get() != nullptr) {
        auto& loader = LooseFileLoader::get(); // Initialize this really early
        auto &integrity_bypass = IntegrityCheckBypass::get_shared_instance();

        const auto config_path = get_persistent_dir(REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data()).string();
        if (fs::exists(utility::widen(config_path))) {
            utility::Config cfg{ config_path };
            loader->on_config_load(cfg);
            integrity_bypass->on_config_load(cfg);
        }

        if (loader->is_enabled()) {
            loader->hook();
        }
    }

    while (true) try {
        const auto tdb = sdk::RETypeDB::get();

        if (tdb == nullptr) {
            spdlog::error("TypeDB not found");
            break;
        }

        // We have to manually look through the types because get_FullName
        // will crash if we call it this early, which is used in get_type(name)
        if (renderer_t == nullptr) {
            for (auto i = 0; i < tdb->get_num_types(); ++i) {
                const auto t = tdb->get_type(i);

                if (t == nullptr || t->get_name() == nullptr || t->get_namespace() == nullptr) {
                    continue;
                }

                if (std::string_view{t->get_name()} == "Renderer" && std::string_view{t->get_namespace()} == "via.render") {
                    spdlog::info("Renderer type found manually @ {:x}", (uintptr_t)t);
                    renderer_t = t;
                    break;
                }
            }
        }

        if (renderer_t == nullptr) {
            spdlog::error("Renderer type not found");
            break;
        }

        renderer_has_render_frame_fn = renderer_t->get_method("get_RenderFrame") != nullptr;

        const auto renderer_has_instance = renderer_t->get_method("hasInstance");

        if (renderer_has_instance == nullptr) {
            spdlog::error("Renderer::hasInstance not found");
            break;
        }

        if (renderer_has_instance->get_function() == nullptr) {
            continue;
        }

        const auto has_instance = renderer_has_instance->call<bool>(nullptr, nullptr); // static

        if (!has_instance) {
            std::this_thread::yield();
            continue;
        }

        renderer = sdk::renderer::get_renderer();

        if (renderer != nullptr) {
            found_renderer = true;
            break;
        }

        spdlog::info("waiting for renderer");
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    } catch(...) {
        spdlog::warn("Exception occurred while waiting for renderer");
        continue;
    }
    
    spdlog::info("Found renderer @ {:x} (type: {:x}), waiting for first frame...", (uintptr_t)renderer, (uintptr_t)renderer_t);

    bool valid_render_frame = false;

    if (renderer_has_render_frame_fn) {
        spdlog::info("Renderer has get_RenderFrame function");
    } else {
        spdlog::info("Renderer does not have get_RenderFrame function");
    }

    while (renderer_has_render_frame_fn) try {
        // This function is static so its fine if renderer is null.
        const auto render_frame = renderer->get_render_frame();

        if (!render_frame.has_value()) {
            spdlog::warn("Render frame property not found");
            break;
        }

        if (*render_frame > 0) {
            spdlog::info("Render frame: {}", *render_frame);
            valid_render_frame = true;
            break;
        }

        std::this_thread::yield();
    } catch(...) {
        //spdlog::warn("Exception occurred while waiting for render frame");
        continue;
    }

    // If all is good, we can immediately hook D3D12 very early
    // else, defer to the hook monitor if anything in the chain failed
    if (valid_render_frame) {
        // We can guaranteed hook at this point
        std::scoped_lock _{m_hook_monitor_mutex};
        hook_d3d12();
    }

    std::scoped_lock _{m_hook_monitor_mutex};

    m_last_present_time = std::chrono::steady_clock::now();
    m_last_message_time = std::chrono::steady_clock::now();
    m_d3d_monitor_thread = std::make_unique<std::jthread>([this](std::stop_token stop_token) {
        while (!stop_token.stop_requested() && !m_terminating) {
            this->hook_monitor();
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
    });
}

bool REFramework::hook_d3d11() {
    //if (m_d3d11_hook == nullptr) {
        m_d3d11_hook.reset();
        m_d3d11_hook = std::make_unique<D3D11Hook>();
        m_d3d11_hook->on_present([this](D3D11Hook& hook) { on_frame_d3d11(); });
        m_d3d11_hook->on_post_present([this](D3D11Hook& hook) { on_post_present_d3d11(); });
        m_d3d11_hook->on_resize_buffers([this](D3D11Hook& hook) { on_reset(); });
    //}

    // Making sure D3D12 is not hooked
    if (!m_is_d3d12) {
        if (m_d3d11_hook->hook()) {
            spdlog::info("Hooked DirectX 11");
            m_valid = true;
            m_is_d3d11 = true;
            return true;
        }
        // We make sure to no unhook any unwanted hooks if D3D11 didn't get hooked properly
        if (m_d3d11_hook->unhook()) {
            spdlog::info("D3D11 unhooked!");
        } else {
            spdlog::info("Cannot unhook D3D11, this might crash.");
        }

        m_valid = false;
        m_is_d3d11 = false;
        return false;
    }

    return false;
}

bool REFramework::hook_d3d12() {
    // windows 7?
    if (LoadLibraryA("d3d12.dll") == nullptr) {
        spdlog::info("d3d12.dll not found, user is probably running Windows 7.");
        spdlog::info("Falling back to hooking D3D11.");

        m_is_d3d12 = false;
        return hook_d3d11();
    }

    //if (m_d3d12_hook == nullptr) {
        m_d3d12_hook.reset();
        m_d3d12_hook = std::make_unique<D3D12Hook>();
        m_d3d12_hook->on_present([this](D3D12Hook& hook) { on_frame_d3d12(); });
        m_d3d12_hook->on_post_present([this](D3D12Hook& hook) { on_post_present_d3d12(); });
        m_d3d12_hook->on_resize_buffers([this](D3D12Hook& hook) { on_reset(); });
        m_d3d12_hook->on_resize_target([this](D3D12Hook& hook) { on_reset(); });
    //}
    //m_d3d12_hook->on_create_swap_chain([this](D3D12Hook& hook) { m_d3d12.command_queue = m_d3d12_hook->get_command_queue(); });

    // Making sure D3D11 is not hooked
    if (!m_is_d3d11) {
        if (m_d3d12_hook->hook()) {
            spdlog::info("Hooked DirectX 12");
            m_valid = true;
            m_is_d3d12 = true;
            return true;
        }
        // We make sure to no unhook any unwanted hooks if D3D12 didn't get hooked properly
        if (m_d3d12_hook->unhook()) {
            spdlog::info("D3D12 Unhooked!");
        } else {
            spdlog::info("Cannot unhook D3D12, this might crash.");
        }

        m_valid = false;
        m_is_d3d12 = false;

        // Try to hook d3d11 instead
        return hook_d3d11();
    }

    return false;
}

REFramework::~REFramework() {
    spdlog::info("REFramework shutting down...");

    m_terminating = true;
    m_d3d_monitor_thread->request_stop();
    if (m_d3d_monitor_thread->joinable()) {
        m_d3d_monitor_thread->join();
    }

    m_d3d_monitor_thread.reset();

    if (m_is_d3d11) {
        deinit_d3d11();
    }

    if (m_is_d3d12) {
        deinit_d3d12();
    }

    ImGui_ImplWin32_Shutdown();

    if (m_initialized) {
        ImGui::DestroyContext();
    }
}

void REFramework::run_imgui_frame(bool from_present) {
    std::scoped_lock _{ m_imgui_mtx };

    m_has_frame = false;

    if (!m_initialized) {
        return;
    }

    const bool is_init_ok = m_error.empty() && m_game_data_initialized;

    consume_input();
    init_fonts();
    
    ImGui_ImplWin32_NewFrame();

    // from_present is so we don't accidentally
    // run script/game code within the present thread.
    if (is_init_ok && !from_present) {
        // Run mod frame callbacks.
        m_mods->on_pre_imgui_frame();
    }

    ImGui::NewFrame();

    if (!from_present) {
        call_on_frame();
    }

    draw_ui();
    m_last_draw_ui = m_draw_ui;

    IMGUIZMO_NAMESPACE::BeginFrame();

    ImGui::EndFrame();
    ImGui::Render();

    m_has_frame = true;

    if (!from_present && m_wants_save_config) {
        save_config();
        m_wants_save_config = false;
    }
}

// D3D11 Draw funciton
void REFramework::on_frame_d3d11() {
    std::scoped_lock _{ m_imgui_mtx };

    spdlog::debug("on_frame (D3D11)");

    m_renderer_type = RendererType::D3D11;

    if (!m_initialized) {
        if (!initialize()) {
            return;
        }

        spdlog::info("REFramework initialized");
        m_initialized = true;
        return;
    }

    if (m_message_hook_requested) {
        initialize_windows_message_hook();
    }

    auto device = m_d3d11_hook->get_device();
    
    if (device == nullptr) {
        spdlog::error("D3D11 device was null when it shouldn't be, returning...");
        m_initialized = false;
        return;
    }

    bool is_init_ok = m_error.empty() && m_game_data_initialized;

    if (is_init_ok) {
        // Write default config once if it doesn't exist.
        if (!std::exchange(m_created_default_cfg, true)) {
            if (!fs::exists({utility::widen(get_persistent_dir(REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data()).string())})) {
                save_config();
            }
        }
    }

    is_init_ok = first_frame_initialize();

    if (!m_has_frame) {
        if (!is_init_ok) {
            init_fonts();
            invalidate_device_objects();

            ImGui_ImplDX11_NewFrame();
            // hooks don't run until after initialization, so we just render the imgui window while initalizing.
            run_imgui_frame(true);
        } else {   
            return;
        }
    } else {
        invalidate_device_objects();
        ImGui_ImplDX11_NewFrame();
    }

    if (is_init_ok) {
        m_mods->on_present();
    }

    ComPtr<ID3D11DeviceContext> context{};
    float clear_color[]{0.0f, 0.0f, 0.0f, 0.0f};

    m_d3d11_hook->get_device()->GetImmediateContext(&context);
    context->ClearRenderTargetView(m_d3d11.blank_rt_rtv.Get(), clear_color);

    // Only render this if VR is running.
    // TODO: Instead use this as an SRV to render to the back buffer so we don't render twice.
    if (VR::get()->is_hmd_active()) {
        context->ClearRenderTargetView(m_d3d11.rt_rtv.Get(), clear_color);
        context->OMSetRenderTargets(1, m_d3d11.rt_rtv.GetAddressOf(), NULL);
        ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());    
    }

    // Set the back buffer to be the render target.
    context->OMSetRenderTargets(1, m_d3d11.bb_rtv.GetAddressOf(), nullptr);
    ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());

    if (is_init_ok) {
        m_mods->on_post_frame();
    }
}

void REFramework::on_post_present_d3d11() {
    if (!m_error.empty() || !m_initialized || !m_game_data_initialized) {
        if (m_last_present_time <= std::chrono::steady_clock::now()){
            m_last_present_time = std::chrono::steady_clock::now();
        }

        return;
    }

    for (auto& mod : m_mods->get_mods()) {
        mod->on_post_present();
    }

    if (m_last_present_time <= std::chrono::steady_clock::now()){
        m_last_present_time = std::chrono::steady_clock::now();
    }
}

// D3D12 Draw funciton
void REFramework::on_frame_d3d12() {
    std::scoped_lock _{ m_imgui_mtx };

    m_renderer_type = RendererType::D3D12;

    auto command_queue = m_d3d12_hook->get_command_queue();
    //spdlog::debug("on_frame (D3D12)");
    
    if (!m_initialized) {
        if (!initialize()) {
            return;
        }

        spdlog::info("REFramework initialized");
        m_initialized = true;
        return;
    }

    if (command_queue == nullptr) {
        spdlog::error("Null Command Queue");
        return;
    }

    if (m_message_hook_requested) {
        initialize_windows_message_hook();
    }

    auto device = m_d3d12_hook->get_device();

    if (device == nullptr) {
        spdlog::error("D3D12 Device was null when it shouldn't be, returning...");
        m_initialized = false;
        return;
    }

    bool is_init_ok = m_error.empty() && m_game_data_initialized;

    if (is_init_ok) {
        // Write default config once if it doesn't exist.
        if (!std::exchange(m_created_default_cfg, true)) {
            if (!fs::exists({utility::widen(get_persistent_dir(REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data()).string())})) {
                save_config();
            }
        }
    }

    auto do_per_frame_thing = [&]() {
        ImGui::GetIO().BackendRendererUserData = m_d3d12.imgui_backend_datas[0];
        const auto prev_cleanup = m_wants_device_object_cleanup;
        invalidate_device_objects();
        ImGui_ImplDX12_NewFrame();

        ImGui::GetIO().BackendRendererUserData = m_d3d12.imgui_backend_datas[1];
        m_wants_device_object_cleanup = prev_cleanup;
        invalidate_device_objects();
        ImGui_ImplDX12_NewFrame();
    };

    is_init_ok = first_frame_initialize();

    if (!m_has_frame) {
        if (!is_init_ok) {
            init_fonts();
            do_per_frame_thing();
            // hooks don't run until after initialization, so we just render the imgui window while initalizing.
            run_imgui_frame(true);
        } else {   
            return;
        }
    } else {
        do_per_frame_thing();
    }

    if (is_init_ok) {
        m_mods->on_present();
    }

    if (m_d3d12.cmd_ctxs.empty()) {
        return;
    }

    auto& cmd_ctx = m_d3d12.cmd_ctxs[m_d3d12.cmd_ctx_index++ % m_d3d12.cmd_ctxs.size()];

    if (cmd_ctx == nullptr) {
        return;
    }

    auto swapchain = m_d3d12_hook->get_swap_chain();
    const auto bb_index = swapchain->GetCurrentBackBufferIndex();

    // Test if our RT for this index is valid.
    if (m_d3d12.get_rt((D3D12::RTV)bb_index) == nullptr) {
        spdlog::error("RTV for index {} is null, reinitializing...", bb_index);
        deinit_d3d12();
        m_has_frame = false;
        m_first_initialize = false;
        m_initialized = false;
        return;
    }

    cmd_ctx->wait(INFINITE);
    {
        std::scoped_lock _{ cmd_ctx->mtx };
        cmd_ctx->has_commands = true;

        // Draw to our render target.
        D3D12_RESOURCE_BARRIER barrier{};
        barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
        barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
        barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;

        D3D12_CPU_DESCRIPTOR_HANDLE rts[1]{};

        // Only render this if VR is running.
        // TODO: Instead use this as an SRV to render to the back buffer so we don't render twice.
        if (VR::get()->is_hmd_active()) {
            barrier.Transition.pResource = m_d3d12.get_rt(D3D12::RTV::IMGUI).Get();
            barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
            barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
            cmd_ctx->cmd_list->ResourceBarrier(1, &barrier);
    
            float clear_color[]{0.0f, 0.0f, 0.0f, 0.0f};
            cmd_ctx->cmd_list->ClearRenderTargetView(m_d3d12.get_cpu_rtv(device, D3D12::RTV::IMGUI), clear_color, 0, nullptr);
            rts[0] = m_d3d12.get_cpu_rtv(device, D3D12::RTV::IMGUI);
            cmd_ctx->cmd_list->OMSetRenderTargets(1, rts, FALSE, NULL);
            cmd_ctx->cmd_list->SetDescriptorHeaps(1, m_d3d12.srv_desc_heap.GetAddressOf());
    
            ImGui::GetIO().BackendRendererUserData = m_d3d12.imgui_backend_datas[1];
            ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), cmd_ctx->cmd_list.Get());
            
            barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
            barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
            cmd_ctx->cmd_list->ResourceBarrier(1, &barrier);
        }

        // Draw to the back buffer.
        barrier.Transition.pResource = m_d3d12.rts[bb_index].Get();
        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
        cmd_ctx->cmd_list->ResourceBarrier(1, &barrier);
        rts[0] = m_d3d12.get_cpu_rtv(device, (D3D12::RTV)bb_index);
        cmd_ctx->cmd_list->OMSetRenderTargets(1, rts, FALSE, NULL);
        cmd_ctx->cmd_list->SetDescriptorHeaps(1, m_d3d12.srv_desc_heap.GetAddressOf());

        ImGui::GetIO().BackendRendererUserData = m_d3d12.imgui_backend_datas[0];
        ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), cmd_ctx->cmd_list.Get());

        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
        cmd_ctx->cmd_list->ResourceBarrier(1, &barrier);

        cmd_ctx->execute();
    }

    if (is_init_ok) {
        m_mods->on_post_frame();
    }
}

void REFramework::on_post_present_d3d12() {
    if (!m_error.empty() || !m_initialized || !m_game_data_initialized) {
        if (m_last_present_time <= std::chrono::steady_clock::now()){
            m_last_present_time = std::chrono::steady_clock::now();
        }

        return;
    }

    if (m_d3d12.graphics_memory != nullptr) {
        auto& hook = get_d3d12_hook();
        auto command_queue = hook->get_command_queue();

        m_d3d12.graphics_memory->Commit(command_queue);
    }
    
    for (auto& mod : m_mods->get_mods()) {
        mod->on_post_present();
    }

    if (m_last_present_time <= std::chrono::steady_clock::now()){
        m_last_present_time = std::chrono::steady_clock::now();
    }
}

void REFramework::on_reset() {
    std::scoped_lock _{ m_imgui_mtx };

    spdlog::info("Reset!");

    if (m_initialized) {
        // fixes text boxes not being able to receive input
        //imgui::reset_keystates();
    }

    // Crashes if we don't release it at this point.
    if (m_is_d3d11) {
        deinit_d3d11();
    }

    if (m_is_d3d12) {
        deinit_d3d12();
    }

    if (m_game_data_initialized) {
        m_mods->on_device_reset();
    }

    m_has_frame = false;
    m_first_initialize = false;
    m_initialized = false;
}

void REFramework::patch_set_cursor_pos() {
    std::scoped_lock _{ m_patch_mtx };

    if (m_set_cursor_pos_patch.get() == nullptr) {
        // Make SetCursorPos ret early
        const auto set_cursor_pos_addr = (uintptr_t)GetProcAddress(GetModuleHandleA("user32.dll"), "SetCursorPos");

        if (set_cursor_pos_addr != 0) {
            spdlog::info("Patching SetCursorPos");
            m_set_cursor_pos_patch = Patch::create(set_cursor_pos_addr, {0xC3});
        }
    }
}

void REFramework::remove_set_cursor_pos_patch() {
    std::scoped_lock _{ m_patch_mtx };

    if (m_set_cursor_pos_patch.get() != nullptr) {
        spdlog::info("Removing SetCursorPos patch");
    }

    m_set_cursor_pos_patch.reset();
}

// https://github.com/PGGB/DeviceStutterFix
bool is_device_controller(PDEV_BROADCAST_HDR hdr, WPARAM w_param) {
    if (hdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
        const auto d_interface = (PDEV_BROADCAST_DEVICEINTERFACE)hdr;

        if (d_interface->dbcc_classguid == XUSB_INTERFACE_CLASS_GUID) {
            spdlog::info("Event {:x}: Relevant device detected", w_param);
            return true;
        }
    }

    spdlog::info("Event {:x}: No relevant device detected", w_param);

    return false;
}

bool REFramework::on_message(HWND wnd, UINT message, WPARAM w_param, LPARAM l_param) {
    m_last_message_time = std::chrono::steady_clock::now();

    if (!m_initialized) {
        return true;
    }

    bool is_mouse_moving{false};
    switch (message) {
    case WM_LBUTTONDOWN:
        m_last_keys[VK_LBUTTON] = true;
        break;
    case WM_LBUTTONUP:
        m_last_keys[VK_LBUTTON] = false;
        break;
    case WM_RBUTTONDOWN:
        m_last_keys[VK_RBUTTON] = true;
        break;
    case WM_RBUTTONUP:
        m_last_keys[VK_RBUTTON] = false;
        break;
    case WM_MBUTTONDOWN:
        m_last_keys[VK_MBUTTON] = true;
        break;
    case WM_MBUTTONUP:
        m_last_keys[VK_MBUTTON] = false;
        break;
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN: {
        const auto menu_key = REFrameworkConfig::get()->get_menu_key()->value();

        if (w_param == menu_key && !m_last_keys[w_param]) {
            std::lock_guard _{m_input_mutex};

            set_draw_ui(!m_draw_ui);
        }

        m_last_keys[w_param] = true;
        
        break;
    }
    case WM_KEYUP:
    case WM_SYSKEYUP:
        m_last_keys[w_param] = false;
        break;
    case WM_KILLFOCUS:
        std::fill(std::begin(m_last_keys), std::end(m_last_keys), false);
        break;
    case WM_INPUT: {
        // RIM_INPUT means the window has focus
        if (GET_RAWINPUT_CODE_WPARAM(w_param) == RIM_INPUT) {
            uint32_t size = sizeof(RAWINPUT);
            RAWINPUT raw{};
            
            // obtain size
            GetRawInputData((HRAWINPUT)l_param, RID_INPUT, nullptr, &size, sizeof(RAWINPUTHEADER));

            auto result = GetRawInputData((HRAWINPUT)l_param, RID_INPUT, &raw, &size, sizeof(RAWINPUTHEADER));

            if (raw.header.dwType == RIM_TYPEMOUSE) {
                m_accumulated_mouse_delta[0] += (float)raw.data.mouse.lLastX;
                m_accumulated_mouse_delta[1] += (float)raw.data.mouse.lLastY;

                // Allowing camera movement when the UI is hovered while not focused
                if (raw.data.mouse.lLastX || raw.data.mouse.lLastY) {
                    is_mouse_moving = true;
                }
            }
        }
    } break;

    // Fixes for stuttering when USB devices are removed/inserted
    // Causes all sorts of random things to happen like DXGI ResizeTarget to get called...
    // Maybe they forgot to add a break statement for WM_DEVICECHANGE and it falls through to some window resizing case?
    // https://github.com/PGGB/DeviceStutterFix
    case WM_DEVICECHANGE:
        switch (w_param) {
            case DBT_DEVICEARRIVAL:
            case DBT_DEVICEREMOVECOMPLETE:
                return is_device_controller((PDEV_BROADCAST_HDR)l_param, w_param);
            default:
                spdlog::info("Event {:x}: skipping", w_param);
                return false;
        }
        
        break;
    case RE_TOGGLE_CURSOR: {
        const auto is_internal_message = l_param != 0;
        const auto return_value = is_internal_message || !m_draw_ui;

        if (!is_internal_message) {
            m_cursor_state = (bool)w_param;
            m_cursor_state_changed = true;
        }

        return return_value;
    } break;
    default:
        break;
    }

    ImGui_ImplWin32_WndProcHandler(wnd, message, w_param, l_param);

    {
        // If the user is interacting with the UI we block the message from going to the game.
        const auto& io = ImGui::GetIO();
        if (m_draw_ui && !m_ui_passthrough) {
            // Fix of a bug that makes the input key down register but the key up will never register
            // when clicking on the ui while the game is not focused
            if (message == WM_INPUT && GET_RAWINPUT_CODE_WPARAM(w_param) == RIM_INPUTSINK)
                return false;

            static std::unordered_set<UINT> forcefully_allowed_messages {
                WM_DEVICECHANGE,
                WM_SHOWWINDOW,
                WM_ACTIVATE,
                WM_ACTIVATEAPP,
                WM_CLOSE,
                WM_DPICHANGED,
                WM_SIZING,
                WM_MOUSEACTIVATE
            };

            if (!forcefully_allowed_messages.contains(message)) {
                if (m_is_ui_focused) {
                    if (io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput)
                        return false;
                } else {
                    if (!is_mouse_moving && (io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput))
                        return false;
                }
            }
        }
    }

    bool any_false = false;

    if (m_game_data_initialized) {
        for (auto& mod : m_mods->get_mods()) {
            if (!mod->on_message(wnd, message, w_param, l_param)) {
                any_false = true;
            }
        }
    }

    return !any_false;
}

// this is unfortunate.
void REFramework::on_direct_input_keys(const std::array<uint8_t, 256>& keys) {
    /*const auto menu_key = REFrameworkConfig::get()->get_menu_key()->value();

    if (keys[menu_key] && m_last_keys[menu_key] == 0) {
        std::lock_guard _{m_input_mutex};

        set_draw_ui(!m_draw_ui);
    }

    m_last_keys = keys;*/
}

std::filesystem::path REFramework::get_persistent_dir() {
    auto return_appdata_dir = []() -> std::filesystem::path {
        char app_data_path[MAX_PATH]{};
        SHGetSpecialFolderPathA(0, app_data_path, CSIDL_APPDATA, false);

        static const auto exe_name = [&]() {
            const auto result = std::filesystem::path(*utility::get_module_path(utility::get_executable())).stem().string();
            const auto dir = std::filesystem::path(app_data_path) / "REFramework" / result;
            std::filesystem::create_directories(dir);

            return result;
        }();

        return std::filesystem::path(app_data_path) / "REFramework" / exe_name;
    };

    if (s_fallback_appdata) {
        return return_appdata_dir();
    }

    if (s_checked_file_permissions) {
        static const auto result = std::filesystem::path(*utility::get_module_path(utility::get_executable())).parent_path();
        return result;
    }

    // Do some tests on the file creation/writing permissions of the current directory
    // If we can't write to the current directory, we fallback to the appdata folder
    try {
        const auto dir = std::filesystem::path(*utility::get_module_path(utility::get_executable())).parent_path();
        const auto test_file = dir / "test.txt";
        std::ofstream test_stream{test_file};
        test_stream << "test";
        test_stream.close();

        std::filesystem::create_directories(dir / "test_dir");
        std::filesystem::remove(test_file);
        std::filesystem::remove(dir / "test_dir");

        s_checked_file_permissions = true;
        s_fallback_appdata = false;
    } catch(...) {
        s_fallback_appdata = true;
        s_checked_file_permissions = true;
        return return_appdata_dir();
    }
    
    return std::filesystem::path(*utility::get_module_path(utility::get_executable())).parent_path();
}

void REFramework::save_config() {
    std::scoped_lock _{m_config_mtx};

    m_wants_save_config = false;

    spdlog::info("Saving config {}", REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data());

    utility::Config cfg{};

    for (auto& mod : m_mods->get_mods()) {
        mod->on_config_save(cfg);
    }

    try {
        if (!cfg.save((get_persistent_dir() / REFrameworkConfig::REFRAMEWORK_CONFIG_NAME.data()).string())) {
            spdlog::error("Failed to save config");
            return;
        }
    } catch(const std::exception& e) {
        spdlog::error("Failed to save config: {}", e.what());
        return;
    } catch(...) {
        spdlog::error("Unexpected error while saving config");
        return;
    }

    spdlog::info("Saved config");
}

void REFramework::set_draw_ui(bool state, bool should_save) {
    std::scoped_lock _{m_config_mtx};

    bool prev_state = m_draw_ui;
    m_draw_ui = state;

    if (m_game_data_initialized) {
        REFrameworkConfig::get()->get_menu_open()->value() = state;
    }

    if (state != prev_state && should_save && m_game_data_initialized) {
        save_config();
    }
}

void REFramework::consume_input() {
    m_mouse_delta[0] = m_accumulated_mouse_delta[0];
    m_mouse_delta[1] = m_accumulated_mouse_delta[1];

    m_accumulated_mouse_delta[0] = 0.0f;
    m_accumulated_mouse_delta[1] = 0.0f;
}

int REFramework::add_font(const std::filesystem::path& filepath, float size) {
    // Look for a font already matching this description.
    for (int i = 0; i < m_additional_fonts.size(); ++i) {
        const auto& font = m_additional_fonts[i];

        if (font.filepath == filepath && abs(font.size - size) < 0.1) {
            return i;
        }
    }

    REFramework::AdditionalFont additional_font{filepath, size};
    if (fs::exists(filepath)) {
        auto path = filepath.string();
        if (!loaded_fonts.contains(path)) {
            loaded_fonts[path] = ImGui::GetIO().Fonts->AddFontFromFileTTF(path.c_str(), size);
        }
        additional_font.font = loaded_fonts[path];
        // font.font = fonts->AddFontFromFileTTF(path.c_str(), font.size);
    } else {
        additional_font.font = m_default_font;
    }

    m_additional_fonts.emplace_back(additional_font);
    
    return m_additional_fonts.size() - 1;
}

void REFramework::init_fonts() {
    if (!m_fonts_need_init) {
        return;
    }

    m_fonts_need_init = false;

    auto& fonts = ImGui::GetIO().Fonts;
    fonts->FontLoader = ImGuiFreeType::GetFontLoader();

    // using 'reframework_pictographic.mode' file to
    // replace '?' to most flag in WorldObjectsViewer
    ImFontConfig custom_icons{};
    custom_icons.FontDataOwnedByAtlas = false;

    const auto fonts_path = REFramework::get_persistent_dir() / "reframework" / "fonts";
    const auto font_path = fonts_path / m_default_font_file;

    // @angelfor3v3r
    auto load_seguiemj_font = [&]() {   
        try {
            wchar_t windows_dir[MAX_PATH]{};
            if (GetWindowsDirectoryW(windows_dir, MAX_PATH) == 0) {
                spdlog::error("Failed to get system directory");
                return;
            }

            const auto seguiemj_path = std::filesystem::path(windows_dir) / "Fonts" / "seguiemj.ttf";

            if (std::filesystem::exists(seguiemj_path)) {
                spdlog::info("Loading Segoe UI Emoji font from: {}", seguiemj_path.string());

                ImFontConfig cfg{};
                cfg.FontDataOwnedByAtlas = true;
                cfg.FontLoaderFlags |= ImGuiFreeTypeLoaderFlags_LoadColor;
                cfg.MergeMode        = true;
                fonts->AddFontFromFileTTF(seguiemj_path.string().c_str(), m_font_size, &cfg);
            } else {
                spdlog::warn("Segoe UI Emoji font not found");
            }
        } catch (const std::exception& e) {
            spdlog::error("Failed to load default font: {}", e.what());
            m_default_font_file = "DEFAULT";
        }
    };

    if (m_default_font_file != "DEFAULT" && fs::exists(font_path)) {
        if (!loaded_fonts.contains(m_default_font_file)) {
            ImFontConfig cfg{};
            cfg.FontDataOwnedByAtlas = true;
            cfg.MergeMode        = false;

            loaded_fonts[m_default_font_file] = fonts->AddFontFromFileTTF(font_path.string().c_str(), m_font_size, &cfg);
        }

        if (loaded_fonts[m_default_font_file] == nullptr) {
            spdlog::error("Failed to load font: {}", m_default_font_file);
            m_default_font_file = "DEFAULT";
        } else {
            load_seguiemj_font();
            m_default_font = loaded_fonts[m_default_font_file];
        }
    } else {
        if (!loaded_fonts.contains("DEFAULT")) {
            ImFontConfig cfg{};
            cfg.FontDataOwnedByAtlas = false;

            loaded_fonts["DEFAULT"] = fonts->AddFontFromMemoryCompressedTTF(RobotoCJKSC_Medium_compressed_data, RobotoCJKSC_Medium_compressed_size, m_font_size, &cfg);

            if (loaded_fonts["DEFAULT"] == nullptr) {
                spdlog::error("Failed to load default font!");
                loaded_fonts["DEFAULT"] = fonts->AddFontDefault();
            } else {
                spdlog::info("Loaded default font: {}", m_default_font_file);
            }

            load_seguiemj_font();
        }
        
        m_default_font = loaded_fonts["DEFAULT"];
    }

    /*if (!loaded_fonts.contains("ICON")) {
        // https://fontawesome.com/
        custom_icons.PixelSnapH = true;
        custom_icons.MergeMode = true;
        custom_icons.FontDataOwnedByAtlas = false;
        static const ImWchar icon_ranges[] = {0xF000, 0xF976, 0}; // ICON_MIN_FA ICON_MAX_FA
        loaded_fonts["ICON"] = fonts->AddFontFromMemoryTTF((void*)af_faprolight_ptr, af_faprolight_size, m_font_size, &custom_icons, icon_ranges);
    }*/

    m_wants_device_object_cleanup = true;
}

void REFramework::invalidate_device_objects() {
    if (!m_wants_device_object_cleanup) {
        return;
    }

    if (m_renderer_type == RendererType::D3D11) {
        ImGui_ImplDX11_InvalidateDeviceObjects();
    } else if (m_renderer_type == RendererType::D3D12) {
        ImGui_ImplDX12_InvalidateDeviceObjects();
    }

    m_wants_device_object_cleanup = false;
}

void REFramework::draw_ui() {
    std::lock_guard _{m_input_mutex};

    ImGui::GetIO().MouseDrawCursor = m_draw_ui && REFrameworkConfig::get()->is_always_show_cursor();
    ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange; // causes bugs with the cursor

    if (!m_draw_ui) {
        remove_set_cursor_pos_patch();

        m_is_ui_focused = false;
        if (m_last_draw_ui) {
            m_windows_message_hook->window_toggle_cursor(m_cursor_state);
        }
        m_dinput_hook->acknowledge_input();
        // ImGui::GetIO().MouseDrawCursor = false;
        return;
    } else {
        patch_set_cursor_pos();
    }
    
    // UI Specific code:
    m_is_ui_focused = ImGui::IsWindowFocused(ImGuiFocusedFlags_AnyWindow);

    if (m_ui_option_transparent) {
        auto& style = ImGui::GetStyle();
        if (m_is_ui_focused) {
            style.Alpha = 1.0f;
        } else {
            if (ImGui::IsWindowHovered(ImGuiFocusedFlags_AnyWindow)) {
                style.Alpha = 0.9f;
            } else {
                style.Alpha = 0.8f;
            }
        }
    } else {
        auto& style = ImGui::GetStyle();
        style.Alpha = 1.0f;
    }

    auto& io = ImGui::GetIO();

    if (io.WantCaptureKeyboard) {
        m_dinput_hook->ignore_input();
    } else {
        m_dinput_hook->acknowledge_input();
    }

    // ImGui::GetIO().MouseDrawCursor = true;
    if (!m_last_draw_ui || m_cursor_state_changed) {
        m_cursor_state_changed = false;
        m_windows_message_hook->window_toggle_cursor(true);
    }

    ImGui::SetNextWindowPos(ImVec2(50, 50), ImGuiCond_::ImGuiCond_FirstUseEver);
    ImGui::SetNextWindowSize(ImVec2(300, 500), ImGuiCond_::ImGuiCond_FirstUseEver);

    ImGui::PushFont(m_default_font, m_font_size);
    static const auto REF_NAME = std::format("REFramework [{}+{}-{:.8}]", REF_TAG, REF_COMMITS_PAST_TAG, REF_COMMIT_HASH);
    bool is_open = true;
    ImGui::Begin(REF_NAME.c_str(), &is_open);
    ImGui::Text("Default Menu Key: Insert");
    ImGui::Checkbox("Transparency", &m_ui_option_transparent);
    ImGui::SameLine();
    ImGui::Text("(?)");
    if (ImGui::IsItemHovered())
        ImGui::SetTooltip("Makes the UI transparent when not focused.");
    ImGui::Checkbox("Input Passthrough", &m_ui_passthrough);
    ImGui::SameLine();
    ImGui::Text("(?)");
    if (ImGui::IsItemHovered())
        ImGui::SetTooltip("Allows mouse and keyboard inputs to register to the game while the UI is focused.");

    // Mods:
    draw_about();

    if (m_error.empty() && m_game_data_initialized) {
        m_mods->on_draw_ui();
    } else if (!m_game_data_initialized) {
        ImGui::TextWrapped("REFramework is currently initializing...");
        ImGui::TextWrapped("This menu will close after initialization if you have the remember option enabled.");
    } else if (!m_error.empty()) {
        ImGui::TextWrapped("REFramework error: %s", m_error.c_str());
    }

    m_last_window_pos = ImGui::GetWindowPos();
    m_last_window_size = ImGui::GetWindowSize();

    ImGui::PopFont();
    ImGui::End();

    // save the menu state in config
    if (!is_open) {
        set_draw_ui(is_open, true);
    } else if (m_draw_ui != m_last_draw_ui) {
        set_draw_ui(m_draw_ui, true);
    }

    // if we pressed the X button to close the menu.
    if (m_last_draw_ui && !m_draw_ui) {
        m_windows_message_hook->window_toggle_cursor(m_cursor_state);
    }
}

void REFramework::draw_about() {
    if (!ImGui::CollapsingHeader("About")) {
        return;
    }

    ImGui::TreePush("About");

    ImGui::Text("Author: praydog");
    ImGui::Text("Inspired by the Kanan project.");
    ImGui::Text("https://github.com/praydog/REFramework");
    ImGui::Text("http://praydog.com");
    ImGui::Text("Branch: %s", REF_BRANCH);
    ImGui::Text("Commits: %i", REF_TOTAL_COMMITS);
    ImGui::Text("Commit hash: %s", std::format("{:.8}", REF_COMMIT_HASH).c_str());
    ImGui::Text("Tag: %s", REF_TAG);
#ifdef REF_COMMITS_PAST_TAG
    ImGui::Text("Commits past tag: %i", REF_COMMITS_PAST_TAG);
#endif
    ImGui::Text("Build date: %s", REF_BUILD_DATE);
    ImGui::Text("Build time: %s", REF_BUILD_TIME);

    if (ImGui::TreeNode("Licenses")) {
        struct License {
            std::string name;
            std::string text;
        };

        static std::array<License, 16> licenses{
            License{ "glm", license::glm },
            License{ "imgui", license::imgui },
            License{ "cimgui", license::cimgui },
            License{ "minhook", license::minhook },
            License{ "spdlog", license::spdlog },
            License{ "robotocjksc", license::roboto_cjk },
            License{ "openvr", license::openvr },
            License{ "lua", license::lua },
            License{ "sol", license::sol },
            License{ "json", license::json },
            License{ "asmjit", license::asmjit },
            License{ "bddisasm", utility::narrow(license::bddisasm) },
            License{ "openxr", license::openxr },
            License{ "imguizmo", license::imguizmo },
            License{ "DirectXTK", license::directxtk },
            License{ "DirectXTK12", license::directxtk },
        };

        for (const auto& license : licenses) {
            if (ImGui::CollapsingHeader(license.name.c_str())) {
                ImGui::TextWrapped(license.text.c_str());
            }
        }

        ImGui::TreePop();
    }

    ImGui::Separator();

    if (m_game_data_initialized && m_error.empty()) {
        try {
            static auto version_t = sdk::find_type_definition("via.version");
            static std::string clean_version{};
            static std::string engine_config{};
            static auto tdb_version = sdk::RETypeDB::get()->version;

            if (version_t != nullptr && clean_version.empty()) {
                auto m = version_t->get_method("getPrettyVersionString");

                if (m != nullptr) {
                    auto pretty_string = m->call<::SystemString*>(sdk::get_thread_context(), nullptr);

                    if (pretty_string != nullptr) {
                        clean_version = utility::re_string::get_string(pretty_string);
                    }
                }
            }

            if (version_t != nullptr && engine_config.empty()) {
                auto m = version_t->get_method("getConfigName");

                if (m != nullptr) {
                    auto config_name = m->call<::SystemString*>(sdk::get_thread_context(), nullptr);

                    if (config_name != nullptr) {
                        engine_config = utility::re_string::get_string(config_name);
                    }
                }
            }

            ImGui::Text("Engine information");
            ImGui::Text(" Config: %s", engine_config.c_str());
            ImGui::Text(" Version: %s", clean_version.c_str());
            ImGui::Text(" TDB Version: %i", tdb_version);
        } catch(...) {
            ImGui::Text("Unable to determine engine version.");
        }
    } else {
        ImGui::Text("Unable to determine engine version.");
    }

    ImGui::TreePop();
}

void REFramework::set_imgui_style() noexcept {
    ImGui::StyleColorsDark();

    auto& style = ImGui::GetStyle();
    style.WindowRounding = 0.0f;
    style.ChildRounding = 0.0f;
    style.PopupRounding = 0.0f;
    style.FrameRounding = 0.0f;
    style.ScrollbarRounding = 2.0f;
    style.GrabRounding = 0.0f;
    style.TabRounding = 0.0f;
    style.WindowBorderSize = 2.0f;
    style.WindowPadding = ImVec2(2.0f, 0.0f);

    auto& colors = ImGui::GetStyle().Colors;
    // Window BG
    colors[ImGuiCol_WindowBg] = ImVec4{0.1f, 0.105f, 0.11f, 1.0f};

    // Navigatation highlight
    colors[ImGuiCol_NavHighlight] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};

    // Progress Bar
    colors[ImGuiCol_PlotHistogram] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};

    // Headers
    colors[ImGuiCol_Header] = ImVec4{0.2f, 0.205f, 0.21f, 1.0f};
    colors[ImGuiCol_HeaderHovered] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};
    colors[ImGuiCol_HeaderActive] = ImVec4{0.55f, 0.5505f, 0.551f, 1.0f};

    // Buttons
    colors[ImGuiCol_Button] = ImVec4{0.2f, 0.205f, 0.21f, 1.0f};
    colors[ImGuiCol_ButtonHovered] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};
    colors[ImGuiCol_ButtonActive] = ImVec4{0.55f, 0.5505f, 0.551f, 1.0f};

    // Checkbox
    colors[ImGuiCol_CheckMark] = ImVec4(0.55f, 0.5505f, 0.551f, 1.0f);

    // Frame BG
    colors[ImGuiCol_FrameBg] = ImVec4{0.211f, 0.210f, 0.25f, 1.0f};
    colors[ImGuiCol_FrameBgHovered] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};
    colors[ImGuiCol_FrameBgActive] = ImVec4{0.55f, 0.5505f, 0.551f, 1.0f};

    // Tabs
    colors[ImGuiCol_Tab] = ImVec4{0.25f, 0.2505f, 0.251f, 1.0f};
    colors[ImGuiCol_TabHovered] = ImVec4{0.38f, 0.3805f, 0.381f, 1.0f};
    colors[ImGuiCol_TabActive] = ImVec4{0.28f, 0.2805f, 0.281f, 1.0f};
    colors[ImGuiCol_TabUnfocused] = ImVec4{0.25f, 0.2505f, 0.251f, 1.0f};
    colors[ImGuiCol_TabUnfocusedActive] = ImVec4{0.8f, 0.805f, 0.81f, 1.0f};

    // Resize Grip
    colors[ImGuiCol_ResizeGrip] = ImVec4{0.2f, 0.205f, 0.21f, 0.0f};
    colors[ImGuiCol_ResizeGripHovered] = ImVec4{0.3f, 0.305f, 0.31f, 1.0f};
    colors[ImGuiCol_ResizeGripActive] = ImVec4{0.55f, 0.5505f, 0.551f, 1.0f};

    // Title
    colors[ImGuiCol_TitleBg] = ImVec4{0.25f, 0.2505f, 0.251f, 1.0f};
    colors[ImGuiCol_TitleBgActive] = ImVec4{0.55f, 0.5505f, 0.551f, 1.0f};
    colors[ImGuiCol_TitleBgCollapsed] = ImVec4{0.25f, 0.2505f, 0.251f, 1.0f};

    // Font
    set_font_size(m_font_size);
}

bool REFramework::initialize() {
    if (m_initialized) {
        return true;
    }

    reframework::setup_exception_handler();

    if (m_first_initialize) {
        m_frames_since_init = 0;
        m_first_initialize = false;
    }

    if (m_frames_since_init < 60) {
        m_frames_since_init++;
        return false;
    }

    if (m_is_d3d11) {
        spdlog::info("Attempting to initialize DirectX 11");

        if (!m_d3d11_hook->is_hooked()) {
            return false;
        }

        auto device = m_d3d11_hook->get_device();
        auto swap_chain = m_d3d11_hook->get_swap_chain();

        // Wait.
        if (device == nullptr || swap_chain == nullptr) {
            m_first_initialize = true;

            spdlog::info("Device or SwapChain null. DirectX 12 may be in use. Unhooking D3D11...");

            // We unhook D3D11
            if (m_d3d11_hook->unhook()) {
                spdlog::info("D3D11 unhooked!");
            } else {
                spdlog::error("Cannot unhook D3D11, this might crash.");
            }

            m_is_d3d11 = false;
            m_valid = false;

            // We hook D3D12
            if (!hook_d3d12()) {
                spdlog::error("Failed to hook D3D12 after unhooking D3D11.");
            }
            return false;
        }

        ID3D11DeviceContext* context = nullptr;
        device->GetImmediateContext(&context);

        DXGI_SWAP_CHAIN_DESC swap_desc{};
        swap_chain->GetDesc(&swap_desc);

        m_wnd = swap_desc.OutputWindow;


        spdlog::info("Window Handle: {0:x}", (uintptr_t)m_wnd);
        spdlog::info("Initializing ImGui");

        IMGUI_CHECKVERSION();
        ImGui::CreateContext();
        ImNodes::SetImGuiContext(ImGui::GetCurrentContext());
        ImNodes::CreateContext();

        set_imgui_style();

        static const auto imgui_ini = (get_persistent_dir() / "ref_ui.ini").string();
        ImGui::GetIO().IniFilename = imgui_ini.c_str();

        spdlog::info("Initializing ImGui Win32");

        if (!ImGui_ImplWin32_Init(m_wnd)) {
            spdlog::error("Failed to initialize ImGui.");
            return false;
        }

        spdlog::info("Creating render target");

        if (!init_d3d11()) {
            spdlog::error("Failed to init D3D11");
            return false;
        }
    } else if (m_is_d3d12) {
        spdlog::info("Attempting to initialize DirectX 12");

        if (!m_d3d12_hook->is_hooked()) {
            return false;
        }

        auto device = m_d3d12_hook->get_device();
        auto swap_chain = m_d3d12_hook->get_swap_chain();

        if (device == nullptr || swap_chain == nullptr) {
            m_first_initialize = true;

            spdlog::info("Device: {:x}", (uintptr_t)device);
            spdlog::info("SwapChain: {:x}", (uintptr_t)swap_chain);

            spdlog::info("Device or SwapChain null. DirectX 11 may be in use. Unhooking D3D12...");

            // We unhook D3D12
            if (m_d3d12_hook->unhook())
                spdlog::info("D3D12 unhooked!");
            else
                spdlog::error("Cannot unhook D3D12, this might crash.");

            m_valid = false;
            m_is_d3d12 = false;

            // We hook D3D11
            if (!hook_d3d11()) {
                spdlog::error("Failed to hook D3D11 after unhooking D3D12.");
            }
            return false;
        }

        DXGI_SWAP_CHAIN_DESC swap_desc{};
        swap_chain->GetDesc(&swap_desc);

        m_wnd = swap_desc.OutputWindow;


        IMGUI_CHECKVERSION();
        ImGui::CreateContext();
        ImNodes::SetImGuiContext(ImGui::GetCurrentContext());
        ImNodes::CreateContext();

        set_imgui_style();

        static const auto imgui_ini = (get_persistent_dir() / "ref_ui.ini").string();
        ImGui::GetIO().IniFilename = imgui_ini.c_str();
        
        if (!ImGui_ImplWin32_Init(m_wnd)) {
            spdlog::error("Failed to initialize ImGui ImplWin32.");
            return false;
        }

        if (!init_d3d12()) {
            spdlog::error("Failed to init D3D12.");
            return false;
        }
    } else {
        return false;
    }

    initialize_windows_message_hook();

    if (m_first_frame) {
        m_dinput_hook = std::make_unique<DInputHook>(m_wnd);
    } else {
        m_dinput_hook->set_window(m_wnd);
    }

    if (m_first_frame) {
        m_first_frame = false;
        initialize_game_data();
    }

    return true;
}

bool REFramework::initialize_game_data() {
    if (m_game_data_initialized || m_started_game_data_thread) {
        return true;
    }

    m_started_game_data_thread = true;

    spdlog::info("Starting game data initialization thread");

    // Game specific initialization stuff
    std::thread init_thread([this]() {
        std::scoped_lock _{this->m_startup_mutex};

        try {
#if defined(MHRISE) || defined(DD2) || TDB_VER >= 74
            if (!g_success_made_ldr_notification) {
                utility::spoof_module_paths_in_exe_dir();
            }
#endif
            reframework::initialize_sdk();

#if TDB_VER >= 71
            const auto start_time = std::chrono::high_resolution_clock::now();

            while (true) {
                try {
                    if (sdk::VM::get() != nullptr) {
                        break;
                    }
                } catch(...) {
                }

                if (std::chrono::high_resolution_clock::now() - start_time > std::chrono::seconds(30)) {
                    spdlog::error("Timed out waiting for VM to initialize.");
                    throw std::runtime_error("Timed out waiting for VM to initialize.");
                }

                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }

            while (true) {
                try {
                    if (sdk::Application::get() != nullptr) {
                        break;
                    }
                } catch(...) {
                }

                if (std::chrono::high_resolution_clock::now() - start_time > std::chrono::seconds(30)) {
                    spdlog::error("Timed out waiting for Application to initialize.");
                    throw std::runtime_error("Timed out waiting for Application to initialize.");
                }

                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
#endif

            m_mods = std::make_unique<Mods>();

            auto e = m_mods->on_initialize();

            if (e) {
                if (e->empty()) {
                    m_error = "An unknown error has occurred.";
                } else {
                    m_error = *e;
                }

                spdlog::error("Initialization of mods failed. Reason: {}", m_error);
            }

            // Need to clean up local objects as this is our own thread, not under control by the engine
            if (auto context = sdk::get_thread_context(); context != nullptr) try {
                context->local_frame_gc();
            } catch(...) {
                spdlog::error("Failed to run local frame GC.");
            }

            m_game_data_initialized = true;
        } catch(const std::exception& e) {
            m_error = e.what();
            m_game_data_initialized = true;
            spdlog::error("Initialization of mods failed. Reason: {}", m_error);
        }
        catch(...) {
            m_error = "An exception has occurred during initialization.";
            m_game_data_initialized = true;
            spdlog::error("Initialization of mods failed. Reason: exception thrown.");
        }

#if defined(MHRISE) || defined(DD2) || TDB_VER >= 74
        if (!g_success_made_ldr_notification) {
            utility::spoof_module_paths_in_exe_dir();
        }
#endif
        spdlog::info("Game data initialization thread finished");
    });

    init_thread.detach();

    return true;
}

bool REFramework::initialize_windows_message_hook() {
    if (m_wnd == 0) {
        return false;
    }

    if (m_first_frame || m_message_hook_requested || m_windows_message_hook == nullptr) {
        m_last_message_time = std::chrono::steady_clock::now();
        m_windows_message_hook.reset();
        m_windows_message_hook = std::make_unique<WindowsMessageHook>(m_wnd);
        m_windows_message_hook->on_message = [this](auto wnd, auto msg, auto w_param, auto l_param) {
            return on_message(wnd, msg, w_param, l_param);
        };

        m_message_hook_requested = false;
        return true;
    }

    m_message_hook_requested = false;
    return false;
}

// Ran on the first valid frame after pre-initialization of mods has taken place and hasn't failed
// This one allows mods to run any initialization code in the context of the D3D thread (like VR code)
// It also is the one that actually loads any config files
bool REFramework::first_frame_initialize() {
    const bool is_init_ok = m_error.empty() && m_game_data_initialized;

    if (!is_init_ok || !m_first_frame_d3d_initialize) {
        return is_init_ok;
    }

    auto do_not_hook_d3d = acquire_do_not_hook_d3d();

    spdlog::info("Running first frame D3D initialization of mods...");

    m_first_frame_d3d_initialize = false;
    auto e = m_mods->on_initialize_d3d_thread();

    if (e) {
        if (e->empty()) {
            m_error = "An unknown error has occurred.";
        } else {
            m_error = *e;
        }

        spdlog::error("Initialization of mods failed. Reason: {}", m_error);
        m_game_data_initialized = false;
        m_mods_fully_initialized = false;
        return false;
    } else {
        // Do an initial config save to set the default values for the frontend
        save_config();
        m_mods_fully_initialized = true;
    }

    // Troubleshooting by logging loaded modules
    // helps us figure out if someone has conflicting software running
    try {
        spdlog::info("Logging loaded modules...");

        const auto loaded_modules = utility::get_loaded_module_names();

        for (const auto& name : loaded_modules) {
            spdlog::info("Loaded module: {}", utility::narrow(name));
        }
    } catch(...) {
        spdlog::error("Failed to get loaded modules.");
    }


    return true;
}

void REFramework::call_on_frame() {
    const bool is_init_ok = m_error.empty() && m_game_data_initialized;

    if (is_init_ok) {
        // Run mod frame callbacks.
        m_mods->on_frame();
    }
}

// DirectX 11 Initialization methods

bool REFramework::init_d3d11() {
    deinit_d3d11();

    auto swapchain = m_d3d11_hook->get_swap_chain();
    auto device = m_d3d11_hook->get_device();

    // Get back buffer.
    spdlog::info("[D3D11] Creating RTV of back buffer...");

    ComPtr<ID3D11Texture2D> backbuffer{};

    if (FAILED(swapchain->GetBuffer(0, IID_PPV_ARGS(&backbuffer)))) {
        spdlog::error("[D3D11] Failed to get back buffer!");
        return false;
    }

    // Create a render target view of the back buffer.
    if (FAILED(device->CreateRenderTargetView(backbuffer.Get(), nullptr, &m_d3d11.bb_rtv))) {
        spdlog::error("[D3D11] Failed to create back buffer render target view!");
        return false;
    }

    // Get backbuffer description.
    D3D11_TEXTURE2D_DESC backbuffer_desc{};

    backbuffer->GetDesc(&backbuffer_desc);
    backbuffer_desc.BindFlags |= D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;

    spdlog::info("[D3D11] Back buffer format is {}", backbuffer_desc.Format);

    // Create our blank render target.
    spdlog::info("[D3D11] Creating render targets...");
    {
        // Create our blank render target.
        auto d3d11_rt_desc = backbuffer_desc;
        d3d11_rt_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // For VR

        if (FAILED(device->CreateTexture2D(&d3d11_rt_desc, nullptr, &m_d3d11.blank_rt))) {
            spdlog::error("[D3D11] Failed to create render target texture!");
            return false;
        }

        // Create our render target
        if (FAILED(device->CreateTexture2D(&d3d11_rt_desc, nullptr, &m_d3d11.rt))) {
            spdlog::error("[D3D11] Failed to create render target texture!");
            return false;
        }
    }

    // Create our blank render target view.
    spdlog::info("[D3D11] Creating rtvs...");

    if (FAILED(device->CreateRenderTargetView(m_d3d11.blank_rt.Get(), nullptr, &m_d3d11.blank_rt_rtv))) {
        spdlog::error("[D3D11] Failed to create render terget view!");
        return false;
    }


    // Create our render target view.
    if (FAILED(device->CreateRenderTargetView(m_d3d11.rt.Get(), nullptr, &m_d3d11.rt_rtv))) {
        spdlog::error("[D3D11] Failed to create render terget view!");
        return false;
    }

    // Create our render target shader resource view.
    spdlog::info("[D3D11] Creating srvs...");

    if (FAILED(device->CreateShaderResourceView(m_d3d11.rt.Get(), nullptr, &m_d3d11.rt_srv))) {
        spdlog::error("[D3D11] Failed to create shader resource view!");
        return false;
    }

    m_d3d11.rt_width = backbuffer_desc.Width;
    m_d3d11.rt_height = backbuffer_desc.Height;

    spdlog::info("[D3D11] Initializing ImGui D3D11...");

    ComPtr<ID3D11DeviceContext> context{};

    device->GetImmediateContext(&context);

    if (!ImGui_ImplDX11_Init(device, context.Get())) {
        spdlog::error("[D3D11] Failed to initialize ImGui.");
        return false;
    }

    return true;
}

void REFramework::deinit_d3d11() {
    ImGui_ImplDX11_Shutdown();
    m_d3d11 = {};
}

// DirectX 12 Initialization methods

bool REFramework::init_d3d12() {
    deinit_d3d12();
    
    auto device = m_d3d12_hook->get_device();

    spdlog::info("[D3D12] Creating DXTK graphics memory...");

    // Realistically we only have one device. If not, then... IDK
    m_d3d12.graphics_memory.reset();
    m_d3d12.graphics_memory = std::make_unique<DirectX::DX12::GraphicsMemory>(device);

    spdlog::info("[D3D12] Creating command allocator...");

    m_d3d12.cmd_ctxs.clear();

    for (auto i = 0; i < 3; ++i) {
        auto& ctx = m_d3d12.cmd_ctxs.emplace_back(std::make_unique<d3d12::CommandContext>());

        if (!ctx->setup(L"Framework::m_d3d12.cmd_ctx")) {
            spdlog::error("[D3D12] Failed to create command context.");
            return false;
        }
    }

    spdlog::info("[D3D12] Creating RTV descriptor heap...");

    {
        D3D12_DESCRIPTOR_HEAP_DESC desc{};

        desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
        desc.NumDescriptors = (int)D3D12::RTV::COUNT; 
        desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
        desc.NodeMask = 1;

        if (FAILED(device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_d3d12.rtv_desc_heap)))) {
            spdlog::error("[D3D12] Failed to create RTV descriptor heap.");
            return false;
        }

        m_d3d12.rtv_desc_heap->SetName(L"Framework::m_d3d12.rtv_desc_heap");
    }

    spdlog::info("[D3D12] Creating SRV descriptor heap...");

    { 
        D3D12_DESCRIPTOR_HEAP_DESC desc{};
        
        desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
        desc.NumDescriptors = (int)D3D12::SRV::COUNT;
        desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;

        if (FAILED(device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_d3d12.srv_desc_heap)))) {
            spdlog::error("[D3D12] Failed to create SRV descriptor heap.");
            return false;
        }

        m_d3d12.srv_desc_heap->SetName(L"Framework::m_d3d12.srv_desc_heap");
    }

    spdlog::info("[D3D12] Creating render targets...");

    auto swapchain = m_d3d12_hook->get_swap_chain();

    DXGI_SWAP_CHAIN_DESC swapchain_desc{};

    if (FAILED(swapchain->GetDesc(&swapchain_desc))) {
        spdlog::error("[D3D12] Failed to get swap chain description.");
        return false;
    }

    spdlog::info("[D3D12] Swapchain buffer count: {}", swapchain_desc.BufferCount);

    {
        // Create back buffer rtvs.
        if (swapchain_desc.BufferCount > (int)D3D12::RTV::BACKBUFFER_LAST + 1) {
            spdlog::warn("[D3D12] Too many back buffers ({} vs {}).", swapchain_desc.BufferCount, (int)D3D12::RTV::BACKBUFFER_LAST + 1);
        }

        for (auto i = 0; i < (int)swapchain_desc.BufferCount; ++i) {
            if (SUCCEEDED(swapchain->GetBuffer(i, IID_PPV_ARGS(&m_d3d12.rts[i])))) {
                device->CreateRenderTargetView(m_d3d12.rts[i].Get(), nullptr, m_d3d12.get_cpu_rtv(device, (D3D12::RTV)i));
            } else {
                spdlog::error("[D3D12] Failed to get back buffer for rtv {}", i);
                m_d3d12.rts[i].Reset(); // just in case
            }
        }

        // Create our imgui and blank rts.
        auto& backbuffer = m_d3d12.get_rt(D3D12::RTV::BACKBUFFER_0);

        if (backbuffer == nullptr) {
            spdlog::error("[D3D12] Failed to get first back buffer RTV.");
            deinit_d3d12();
            return false;
        }

        auto desc = backbuffer->GetDesc();

        spdlog::info("[D3D12] Back buffer format is {}", desc.Format);

        D3D12_HEAP_PROPERTIES props{};
        props.Type = D3D12_HEAP_TYPE_DEFAULT;
        props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
        props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;

        auto d3d12_rt_desc = desc;
        d3d12_rt_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // For VR

        D3D12_CLEAR_VALUE clear_value{};
        clear_value.Format = d3d12_rt_desc.Format;

        if (FAILED(device->CreateCommittedResource(&props, D3D12_HEAP_FLAG_NONE, &d3d12_rt_desc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, &clear_value,
                IID_PPV_ARGS(&m_d3d12.get_rt(D3D12::RTV::IMGUI))))) {
            spdlog::error("[D3D12] Failed to create the imgui render target.");
            return false;
        }

        m_d3d12.get_rt(D3D12::RTV::IMGUI)->SetName(L"Framework::m_d3d12.rts[IMGUI]");

        if (FAILED(device->CreateCommittedResource(&props, D3D12_HEAP_FLAG_NONE, &d3d12_rt_desc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, &clear_value,
                IID_PPV_ARGS(&m_d3d12.get_rt(D3D12::RTV::BLANK))))) {
            spdlog::error("[D3D12] Failed to create the blank render target.");
            return false;
        }

        m_d3d12.get_rt(D3D12::RTV::BLANK)->SetName(L"Framework::m_d3d12.rts[BLANK]");

        // Create imgui and blank rtvs and srvs.
        device->CreateRenderTargetView(m_d3d12.get_rt(D3D12::RTV::IMGUI).Get(), nullptr, m_d3d12.get_cpu_rtv(device, D3D12::RTV::IMGUI));
        device->CreateRenderTargetView(m_d3d12.get_rt(D3D12::RTV::BLANK).Get(), nullptr, m_d3d12.get_cpu_rtv(device, D3D12::RTV::BLANK));
        device->CreateShaderResourceView(
            m_d3d12.get_rt(D3D12::RTV::IMGUI).Get(), nullptr, m_d3d12.get_cpu_srv(device, D3D12::SRV::IMGUI_VR));
        device->CreateShaderResourceView(m_d3d12.get_rt(D3D12::RTV::BLANK).Get(), nullptr, m_d3d12.get_cpu_srv(device, D3D12::SRV::BLANK));

        m_d3d12.rt_width = (uint32_t)desc.Width;
        m_d3d12.rt_height = (uint32_t)desc.Height;
    }

    spdlog::info("[D3D12] Initializing ImGui...");

    auto& bb = m_d3d12.get_rt(D3D12::RTV::BACKBUFFER_0);
    auto bb_desc = bb->GetDesc();

    ImGui_ImplDX12_InitInfo init_info{};
    init_info.Device = device;
    init_info.CommandQueue = g_framework->get_d3d12_hook()->get_command_queue();
    init_info.NumFramesInFlight = swapchain_desc.BufferCount;
    init_info.RTVFormat = bb_desc.Format;
    init_info.DSVFormat = DXGI_FORMAT_UNKNOWN;
    init_info.SrvDescriptorHeap = m_d3d12.srv_desc_heap.Get();
    init_info.LegacySingleSrvCpuDescriptor = m_d3d12.get_cpu_srv(device, D3D12::SRV::IMGUI_FONT_BACKBUFFER);
    init_info.LegacySingleSrvGpuDescriptor = m_d3d12.get_gpu_srv(device, D3D12::SRV::IMGUI_FONT_BACKBUFFER);

    if (!ImGui_ImplDX12_Init(&init_info)) {
        spdlog::error("[D3D12] Failed to initialize ImGui.");
        return false;
    }

    m_d3d12.imgui_backend_datas[0] = ImGui::GetIO().BackendRendererUserData;

    ImGui::GetIO().BackendRendererUserData = nullptr;

    // Now initialize another one for the VR texture.
    auto& bb_vr = m_d3d12.get_rt(D3D12::RTV::IMGUI);
    auto bb_vr_desc = bb_vr->GetDesc();

    ImGui_ImplDX12_InitInfo init_info_vr{};
    init_info_vr.Device = device;
    init_info_vr.CommandQueue = g_framework->get_d3d12_hook()->get_command_queue();
    init_info_vr.NumFramesInFlight = swapchain_desc.BufferCount;
    init_info_vr.RTVFormat = bb_vr_desc.Format;
    init_info_vr.DSVFormat = DXGI_FORMAT_UNKNOWN;
    init_info_vr.SrvDescriptorHeap = m_d3d12.srv_desc_heap.Get();
    init_info_vr.LegacySingleSrvCpuDescriptor = m_d3d12.get_cpu_srv(device, D3D12::SRV::IMGUI_FONT_VR);
    init_info_vr.LegacySingleSrvGpuDescriptor = m_d3d12.get_gpu_srv(device, D3D12::SRV::IMGUI_FONT_VR);

    if (!ImGui_ImplDX12_Init(&init_info_vr)) {
        spdlog::error("[D3D12] Failed to initialize ImGui.");
        return false;
    }
    m_d3d12.imgui_backend_datas[1] = ImGui::GetIO().BackendRendererUserData;

    return true;
}

void REFramework::deinit_d3d12() {
    for (auto& ctx : m_d3d12.cmd_ctxs) {
        if (ctx != nullptr) {
            ctx->reset();
        }
    }

    m_d3d12.cmd_ctxs.clear();

    for (auto userdata : m_d3d12.imgui_backend_datas) {
        if (userdata != nullptr) {
            ImGui::GetIO().BackendRendererUserData = userdata;
            ImGui_ImplDX12_Shutdown();
        }
    }

    ImGui::GetIO().BackendRendererUserData = nullptr;
    m_d3d12 = {};
}