Add Little Nightmares

LittleNightmares/dllmain.cpp

@@ -0,0 +1,437 @@
+#include "CommonHeaders.h"
+#include "GameFixes.h"
+#include "GameInformations.h"
+#include "ObfuscateString.h"
+#include "Memory.hpp"
+#include "Maths.hpp"
+#include "UEngine.hpp"
+#include "SDK/Basic.hpp"
+#include "SDK/Engine_classes.hpp"
+
+using namespace SDK;
+
+// Constants
+const std::string PLUGIN_NAME = "LittleNightmares";
+const std::string PLUGIN_LOG = PLUGIN_NAME + ".log";
+const float baseAspect = 1.777778;
+
+// Logger
+std::shared_ptr<spdlog::logger> logger;
+
+// Screen informations
+static int screenWidth = GetSystemMetrics(SM_CXSCREEN);
+static int screenHeight = GetSystemMetrics(SM_CYSCREEN);
+static float aspectRatio = (float)screenWidth / screenHeight;
+
+// Plugin states
+static bool AOBScanDone = false;
+static bool g_fix_enabled = false;
+static bool g_fov_fix_enabled = false;
+static bool g_FPS_fix_enabled = false;
+static bool g_ultrawide_fix_enabled = false;
+static bool g_DOF_fix_enabled = false;
+static bool g_CA_fix_enabled = false;
+static bool g_Vignetting_fix_enabled = false;
+static bool g_Fog_fix_enabled = false;
+static bool g_Console = false;
+static int g_AdditionalFOVValue = 0;
+
+// Shared values
+static float g_FOV_In = 70.f;
+static float g_CompensatedFOV = 70.f;
+static float g_FOV_Out = 70.f;
+static bool g_Console_Enabled = false;
+
+// AOB Unreal Engine offsets addresses
+static uint8_t* GObjectsaddress = nullptr;
+static uint8_t* AppendStringaddress = nullptr;
+static uint8_t* ProcessEventaddress = nullptr;
+
+// AOB Scan pointers
+static uint8_t* FOVaddress = nullptr;
+static uint8_t* DOFaddress = nullptr;
+static uint8_t* CAaddress = nullptr;
+static uint8_t* Vignettingaddress = nullptr;
+static uint8_t* Fogaddress = nullptr;
+static uint8_t* UltraWideaddress = nullptr;
+static uint8_t* FPSaddress = nullptr;
+
+// Hooking
+static SafetyHookMid FOVHook{};
+static SafetyHookMid FPSHook{};
+static SafetyHookMid VignettingHook{};
+static SafetyHookMid FogHook{};
+
+// Prototypes
+static void FOVFixEnabled();
+static void FPSFixEnabled();
+static void UltraWideFixEnabled();
+static void DOFFixEnabled();
+static void CAFixEnabled();
+static void VignettingFixEnabled();
+static void FogFixEnabled();
+static void EnableConsole();
+
+extern "C" __declspec(dllexport) void SetFixEnabled(bool enabled, bool init)
+{
+    g_fix_enabled = enabled;
+    if (g_fix_enabled && !AOBScanDone) {
+        logger->info("--------------- AOB scan started ---------------");
+        if (!FOVaddress) {
+            constexpr auto FOVStringObfuscated = make_obfuscated<0x4A>("74 ?? E8 ?? ?? ?? ?? 0F ?? ?? 48 8B ?? ?? ?? ?? ?? ?? 48 ?? ?? E8 ?? ?? ?? ?? 0F 28 ?? ?? ?? ?? ?? ?? 48 81 ?? ?? ?? ?? ?? C3");
+            FOVaddress = Memory::AOBScan("", FOVStringObfuscated.decrypt(), PAGE_EXECUTE_READ, logger);
+
+            if (!FOVaddress)
+                logger->warn("FOV signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("FOV found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(FOVaddress));
+        }
+
+        if (!UltraWideaddress) {
+            constexpr auto AspectRatioAxisConstraintStringObfuscated = make_obfuscated<0x4A>("C7 80 ?? ?? ?? ?? 3B 8E E3 3F 48 8B");
+            UltraWideaddress = Memory::AOBScan("", AspectRatioAxisConstraintStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!UltraWideaddress)
+                logger->warn("Aspect ratio signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("Aspect ratio found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(UltraWideaddress));
+        }
+
+        if (!DOFaddress) {
+            constexpr auto DOFStringObfuscated = make_obfuscated<0x4A>("8B ?? ?? E8 ?? ?? ?? ?? 8B ?? E8 ?? ?? ?? ?? 84 ?? 74 ?? 48");
+            DOFaddress = Memory::AOBScan("", DOFStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!DOFaddress)
+                logger->warn("DOF signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("DOF signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(DOFaddress));
+        }
+
+        if (!CAaddress) {
+            constexpr auto CAStringObfuscated = make_obfuscated<0x4A>("7F ?? 89 AB ?? ?? ?? ?? 42 ?? ?? ?? 39 05 ?? ?? ?? ?? 7E");
+            CAaddress = Memory::AOBScan("", CAStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!CAaddress)
+                logger->warn("Chromatic aberrations signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("Chromatic aberrations signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(CAaddress));
+        }
+
+        if (!Vignettingaddress) { // B1 01
+            constexpr auto CAStringObfuscated = make_obfuscated<0x4A>("83 ?? ?? 7D ?? 89 AB ?? ?? ?? ?? 89 AB ?? ?? ?? ?? 89 AB ?? ?? ?? ?? 89");
+            Vignettingaddress = Memory::AOBScan("", CAStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!Vignettingaddress)
+                logger->warn("Vignetting signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("Vignetting signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Vignettingaddress));
+        }
+
+        if (!Fogaddress) {
+            constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("83 ?? ?? ?? 75 ?? B3 ?? EB ?? 32 ?? 48 ?? ?? ?? ?? 48 ?? ?? 74");
+            Fogaddress = Memory::AOBScan("", FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!Fogaddress)
+                logger->warn("Fog signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("Fog signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Fogaddress));
+        }
+
+        if (!FPSaddress) {
+            constexpr auto FPSStringObfuscated = make_obfuscated<0x4A>("F3 0F ?? ?? ?? 80 BF ?? ?? ?? ?? ?? 48 8B ?? ?? ?? 48 8B");
+            FPSaddress = Memory::AOBScan("", FPSStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!FPSaddress)
+                logger->warn("Framerate signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else
+                logger->info("Framerate signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(FPSaddress));
+        }
+
+        if (FOVaddress && DOFaddress && CAaddress && Vignettingaddress && Fogaddress && UltraWideaddress && FPSaddress)
+            logger->info("All AOB signatures found. Ready to patch...");
+
+        AOBScanDone = true;
+
+        if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) {
+            logger->info("------------ UEngine offsets search ------------");
+            uint8_t* baseModule = reinterpret_cast<uint8_t*>(GetModuleHandleA(nullptr)); // Get game base address
+
+            constexpr auto GObjetcsStringObfuscated = make_obfuscated<0x4A>("48 8B ?? ?? ?? ?? ?? 48 8B ?? ?? 48 8D ?? ?? EB ?? 33");
+            GObjectsaddress = Memory::AOBScan("", GObjetcsStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+            constexpr auto AppendStringStringObfuscated = make_obfuscated<0x4A>("48 89 ?? ?? ?? 48 89 ?? ?? ?? 57 48 ?? ?? ?? 8B ?? 48 ?? ?? 8B ?? 48 ?? ?? C1 ?? ?? 80 3D ?? ?? ?? ?? ?? 0F ?? ?? 89 ?? ?? ?? 89 ?? ?? ?? 74 ?? 4C 8D ?? ?? ?? ?? ?? EB ?? 48 8D ?? ?? ?? ?? ?? E8 ?? ?? ?? ?? 4C ?? ?? C6 05 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? 48 ?? ?? 48 ?? ?? ?? 8D ?? ?? 49 ?? ?? ?? ?? E8 ?? ?? ?? ?? 83");
+            AppendStringaddress = Memory::AOBScan("", AppendStringStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+            constexpr auto ProcessEventStringObfuscated = make_obfuscated<0x4A>("40 ?? 56 57 41 ?? 41 ?? 41 ?? 41 ?? 48 81 ?? ?? ?? ?? ?? 48 8D ?? ?? ?? 48 89 ?? ?? ?? ?? ?? 48 8B ?? ?? ?? ?? ?? 48 33 ?? 48 89 ?? ?? ?? ?? ?? 8B 41");
+            ProcessEventaddress = Memory::AOBScan("", ProcessEventStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
+
+            if (!GObjectsaddress)
+                logger->warn("GObjects signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else {
+                uint32_t gObjectsOffset = static_cast<uint32_t>(Memory::GetOffsetFromOpcode(GObjectsaddress + 0x3) - baseModule);
+                logger->info("GObjects offset is: 0x{:X}.", gObjectsOffset);
+                Offsets::GObjects = static_cast<UC::uint32>(gObjectsOffset); // Update GObjects offset
+            }
+
+            if (!AppendStringaddress)
+                logger->warn("AppendString signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else {
+                std::optional<uint32_t> gAppendStringOffsetOpt = UE::CalculateOffset("", AppendStringaddress);
+                uint32_t gAppendStringOffset = *gAppendStringOffsetOpt;
+                logger->info("AppendString offset is: 0x{:X}.", gAppendStringOffset);
+                Offsets::AppendString = static_cast<UC::uint32>(gAppendStringOffset);// Update AppendString offset
+            }
+
+            if (!ProcessEventaddress)
+                logger->warn("Process Event signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
+            else {
+                std::optional<uint32_t> gProcessEventOffsetOpt = UE::CalculateOffset("", ProcessEventaddress);
+                uint32_t gProcessEventOffset = *gProcessEventOffsetOpt;
+                logger->info("Process Event offset is: 0x{:X}.", gProcessEventOffset);
+                Offsets::ProcessEvent = static_cast<UC::uint32>(gProcessEventOffset);// Update ProcessEvent offset
+            }
+        }
+
+        logger->info("-------------- Fixes initialisation -------------");
+    }
+
+    if (!init && FOVaddress) FOVFixEnabled();
+    if (!init && DOFaddress) DOFFixEnabled();
+    if (!init && CAaddress) CAFixEnabled();
+    if (!init && Vignettingaddress) VignettingFixEnabled();
+    if (!init && Fogaddress) FogFixEnabled();
+    if (!init && UltraWideaddress) UltraWideFixEnabled();
+    if (!init && FPSaddress) FPSFixEnabled();
+    if (!init) EnableConsole();
+}
+
+// Setters for Reshade addon call
+extern "C" __declspec(dllexport) void SetFixesEnabled(GameFixes fix, bool enabled)
+{ // Set each fix individually
+    if (fix == GameFixes::DevConsole)           { g_Console = enabled; EnableConsole(); }
+    if (fix == GameFixes::FOV)                  { g_fov_fix_enabled = enabled; FOVFixEnabled(); }
+    if (fix == GameFixes::UltraWide)            { g_ultrawide_fix_enabled = enabled; UltraWideFixEnabled(); }
+    if (fix == GameFixes::Framerate)            { g_FPS_fix_enabled = enabled; FPSFixEnabled(); }
+    if (fix == GameFixes::DOF)                  { g_DOF_fix_enabled = enabled; DOFFixEnabled(); }
+    if (fix == GameFixes::ChromaticAberrations) { g_CA_fix_enabled = enabled; CAFixEnabled(); }
+    if (fix == GameFixes::Vignetting)           { g_Vignetting_fix_enabled = enabled; VignettingFixEnabled(); }
+    if (fix == GameFixes::Fog)                  { g_Fog_fix_enabled = enabled; FogFixEnabled(); }
+}
+
+extern "C" __declspec(dllexport) void SetFOV(int fov)
+{
+    g_AdditionalFOVValue = fov;
+}
+
+// Getters for Reshade addon call
+extern "C" __declspec(dllexport) void GetGameInfos(GameInfos* infos) {
+    if (!infos) return;
+
+    infos->FOVIn = g_FOV_In;
+    infos->FOVOut = g_FOV_Out;
+    infos->CompensatedFOV = g_CompensatedFOV;
+    infos->consoleEnabled = g_Console_Enabled;
+}
+
+// Code injection functions
+static void FOVFixEnabled() {
+    if (g_fix_enabled && (g_fov_fix_enabled || g_ultrawide_fix_enabled) && FOVaddress) {
+        if (!FOVHook) { // Hook only once
+            FOVHook = safetyhook::create_mid(FOVaddress + 0x7,
+                [](SafetyHookContext& ctx) {
+                    g_FOV_In = ctx.xmm6.f32[0];
+                    // FOV compensation when ultrawide is checked
+                    if (aspectRatio > baseAspect && g_ultrawide_fix_enabled)
+                        ctx.xmm6.f32[0] = Maths::CompensateHorizontalFOV(g_FOV_In, baseAspect, aspectRatio);
+                    g_CompensatedFOV = ctx.xmm6.f32[0];
+                    // Additional FOV
+                    ctx.xmm6.f32[0] += (g_fix_enabled && g_fov_fix_enabled ? g_AdditionalFOVValue : 0);
+                    g_FOV_Out = ctx.xmm6.f32[0];
+                });
+        }
+        else FOVHook.enable();
+        logger->info("FOV fix enabled");
+    }
+    if (!(g_fix_enabled && (g_fov_fix_enabled || g_ultrawide_fix_enabled)) && FOVaddress) {
+        if (FOVHook) FOVHook.disable();
+        logger->info("FOV fix disabled");
+    }
+}
+
+static void VignettingFixEnabled() {
+    if (g_fix_enabled && g_Vignetting_fix_enabled && Vignettingaddress) {
+        if (!VignettingHook) { // Hook only once
+            VignettingHook = safetyhook::create_mid(Vignettingaddress,
+                [](SafetyHookContext& ctx) {
+                    ctx.rcx = 1; // Set low vignette r.Tonemapper.Quality=1 (0 is too bright)
+                });
+        }
+        else VignettingHook.enable();
+        logger->info("Vignetting fix enabled");
+    }
+    if (!(g_fix_enabled && g_Vignetting_fix_enabled) && Vignettingaddress) {
+        if (VignettingHook) VignettingHook.disable();
+        logger->info("Vignetting fix disabled");
+    }
+}
+
+static void FogFixEnabled() {
+    if (g_fix_enabled && g_Fog_fix_enabled && Fogaddress) {
+        if (!FogHook) {
+            FogHook = safetyhook::create_mid(Fogaddress,
+                [](SafetyHookContext& ctx) {
+                    if (!ctx.rax) return;
+                    uintptr_t* rax = reinterpret_cast<uintptr_t*>(ctx.rax);
+                    bool* bFog = reinterpret_cast<bool*>(reinterpret_cast<uint8_t*>(rax) + 0x04);
+                    *bFog = g_fix_enabled && g_Fog_fix_enabled ? false : true;
+                });
+        }
+        logger->info("Fog fix enabled");
+    }
+    if (!(g_fix_enabled && g_Fog_fix_enabled) && Fogaddress)
+        logger->info("Fog fix disabled");
+}
+
+static void FPSFixEnabled() {
+    if (g_fix_enabled && g_FPS_fix_enabled && FPSaddress) {
+        if (!FPSHook) {
+            FPSHook = safetyhook::create_mid(FPSaddress + 0x5,
+                [](SafetyHookContext& ctx) {
+                    ctx.xmm6.f32[0] = 0; // Set unlimited framerate
+                });
+        }
+        else FPSHook.enable();
+        logger->info("Framerate fix enabled");
+    }
+    if (!(g_fix_enabled && g_FPS_fix_enabled) && FPSaddress) {
+        if (FPSHook) FPSHook.disable();
+        logger->info("Framerate fix disabled");
+    }
+}
+
+// Memory patch fixes
+static void UltraWideFixEnabled() {
+    if (g_fix_enabled && g_ultrawide_fix_enabled && UltraWideaddress) {
+        const char* newAspectRatio = Memory::Float32ToHexBytes(aspectRatio); // Converts new apsect ratio in 4 char bytes
+        Memory::PatchBytes(UltraWideaddress + 0x6, newAspectRatio, 4);  // mov [rax+00000208],3FE38E3B <= patched
+        logger->info("Ultrawide fix enabled");
+        FOVFixEnabled();
+    }
+    if (!(g_fix_enabled && g_ultrawide_fix_enabled) && UltraWideaddress) {
+        Memory::RestoreBytes(UltraWideaddress + 0x6);
+        logger->info("Ultrawide fix disabled");
+        if (!g_fov_fix_enabled)
+            FOVFixEnabled();
+    }
+}
+
+static void DOFFixEnabled() { // Depth of field (bokeh)
+    if (g_fix_enabled && g_DOF_fix_enabled && DOFaddress) {
+        Memory::PatchBytes(DOFaddress, "\x31\xFF\x90", 3); // xor edi,edi r.DepthOfFieldQuality = 0
+        logger->info("Depth of field fix enabled");
+    }
+    if (!(g_fix_enabled && g_DOF_fix_enabled) && DOFaddress) {
+        Memory::RestoreBytes(DOFaddress);
+        logger->info("Depth of field fix disabled");
+    }
+}
+
+static void CAFixEnabled() { // Chromatic aberrations
+    if (g_fix_enabled && g_CA_fix_enabled && CAaddress) {
+        Memory::PatchBytes(CAaddress, "\x90\x90", 2); // NOP x 2 r.SceneColorFringeQuality = 0
+        logger->info("Chromatics aberrations fix enabled");
+    }
+    if (!(g_fix_enabled && g_CA_fix_enabled) && CAaddress) {
+        Memory::RestoreBytes(CAaddress);
+        logger->info("Chromatics aberrations fix disabled");
+    }
+}
+
+// UE Console creation
+static void EnableConsole()
+{
+    if (!g_Console) {
+        logger->info("------------------ User inputs ------------------");
+        return;
+    }
+
+    logger->info("-------------- Console re-enabling --------------");
+    if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) {
+        logger->warn("Could not re-enable console");
+        logger->info("------------------ User inputs ------------------");
+        return;
+    }
+
+    std::thread([&]() {
+        auto start = std::chrono::high_resolution_clock::now(); // Measure the time to renable console
+        UEngine* Engine = nullptr;
+
+        for (int i = 0; i < 100; ++i) { // gives 10 seconds to find UE Engine
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            Engine = UEngine::GetEngine();
+            if (Engine && Engine->ConsoleClass && Engine->GameViewport)
+                break;
+        }
+
+        if (!Engine || !Engine->ConsoleClass || !Engine->GameViewport) {
+            logger->error("Console could not be found in engine.");
+            return;
+        }
+        logger->info("Console found in engine");
+
+        /* Creates a new UObject of class-type specified by Engine->ConsoleClass */
+        UObject* NewObject = UGameplayStatics::SpawnObject(Engine->ConsoleClass, Engine->GameViewport);
+        if (NewObject)
+        {
+            logger->info("Successfully spawned console object");
+            // Set the console viewport so that it will be displayed
+            Engine->GameViewport->ViewportConsole = static_cast<UConsole*>(NewObject);
+            auto end = std::chrono::high_resolution_clock::now();
+            std::chrono::duration<double> elapsed = end - start;
+
+            for (int i = 0; i < UInputSettings::GetDefaultObj()->ConsoleKeys.Num(); i++)
+            {
+                UInputSettings::GetDefaultObj()->ConsoleKeys[i].KeyName = UKismetStringLibrary::Conv_StringToName(L"F2");
+            }
+            logger->info("Console fully reactivated in {:.3f}s and bound to key F2", elapsed.count());
+            logger->info("------------------ User inputs ------------------");
+
+            g_Console_Enabled = true;
+        }
+        else {
+            logger->error("Could not spawn console object");
+        }
+    }).detach();
+}
+
+static void InitializeLogger()
+{
+    try
+    {
+        std::filesystem::path log_path = std::filesystem::absolute(PLUGIN_LOG);
+        if (std::filesystem::exists(log_path))
+            std::filesystem::remove(log_path);
+        logger = std::make_shared<spdlog::logger>("Little Nightmares", std::make_shared<spdlog::sinks::rotating_file_sink_st>(PLUGIN_LOG, 10 * 1024 * 1024, 1));
+        logger->set_level(spdlog::level::debug);
+        logger->flush_on(spdlog::level::debug); // Flush automatically
+    }
+    catch (const spdlog::spdlog_ex& ex)
+    {
+        std::string plugin_error_message = "Could not open " + PLUGIN_LOG;
+        MessageBoxA(nullptr, plugin_error_message.c_str(), "Logger Error", MB_ICONERROR | MB_OK);
+    }
+}
+
+// Standard dll entry
+BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        InitializeLogger();
+        logger->info("Plugin {} loaded.", PLUGIN_NAME);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        logger->info("Plugin {} unloaded.", PLUGIN_NAME);
+        spdlog::drop_all();
+    }
+    return TRUE;
+}