607 lines
30 KiB
C++
607 lines
30 KiB
C++
#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"
|
|
#include "SDK/Charlie_classes.hpp"
|
|
#include "SDK/UMG_classes.hpp"
|
|
#include "HUD_PlayerStatus_SUMG_classes.hpp"
|
|
|
|
using namespace SDK;
|
|
|
|
// Constants
|
|
const std::string PLUGIN_NAME = "HellIsUs";
|
|
const std::string PLUGIN_LOG = PLUGIN_NAME + ".log";
|
|
const std::string gameExecutable = "HellIsUs-Win64-Shipping.exe";
|
|
const float BASE_ASPECT = 1.777777791;
|
|
const float DEFAULT_WORLD_FOV = 70.f;
|
|
const float DEFAULT_CAMERA_HEIGHT = -15.f;
|
|
|
|
// 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_aspect_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_Camera_fix_enabled = false;
|
|
static bool g_HUD_fix_enabled = false;
|
|
static int g_AdditionalFOVValue = 0;
|
|
static float g_cameraDistanceMultiplier = 1.f;
|
|
static float g_cameraHeight = -15.f;
|
|
static bool g_Console = false;
|
|
|
|
// Shared values
|
|
static float g_FOV_In = 70.f;
|
|
static float g_Compensated_FOV = 70.f;
|
|
static float g_FOV_Out = 70.f;
|
|
static float g_Camera_In = 550.f;
|
|
static float g_Camera_Out = 550.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* Aspectaddress = nullptr;
|
|
static uint8_t* DOFaddress = nullptr;
|
|
static uint8_t* CAaddress = nullptr;
|
|
static uint8_t* Vignettingaddress = nullptr;
|
|
static uint8_t* Fogaddress = nullptr;
|
|
static uint8_t* Cameraaddress = nullptr;
|
|
static uint8_t* HUDaddress = nullptr;
|
|
static uint8_t* SetAnchorsaddress = nullptr;
|
|
|
|
// Hooking
|
|
static SafetyHookMid FOVHook{};
|
|
static SafetyHookMid AspectHook{};
|
|
static SafetyHookMid FogHook{};
|
|
static SafetyHookMid CameraHook{};
|
|
static SafetyHookMid HUDHook{};
|
|
static SafetyHookMid HUDProcessEventHook{};
|
|
|
|
// HUD anchors
|
|
static FAnchors HUDAnchors = {{ 0.f, 0.f }, { 0.f , 1.f }};
|
|
static FAnchors referenceHUDAnchors = { { 0.25f, 0.f }, { 0.25f , 1.f } };
|
|
static FAnchors defaultHUDAnchors = {{ 0.f, 0.f }, { 1.f, 1.f }}; // Will be displayed on all screen viewport
|
|
|
|
// Camera Mode
|
|
enum class ECharlieCameraMode : uint8_t
|
|
{
|
|
Camera = 1,
|
|
FOV = 2
|
|
};
|
|
|
|
// Prototypes
|
|
static void FOVFixEnabled();
|
|
static void AspectFixEnabled();
|
|
static void DOFFixEnabled();
|
|
static void CAFixEnabled();
|
|
static void VignettingFixEnabled();
|
|
static void FogFixEnabled();
|
|
static void CameraFixEnabled(ECharlieCameraMode Mode);
|
|
static void HUDFixEnabled();
|
|
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 == nullptr) {
|
|
constexpr auto FOVStringObfuscated = make_obfuscated<0x4A>("77 ?? 48 ?? ?? FF ?? ?? ?? ?? ?? F3 0F ?? ?? ?? 48");
|
|
FOVaddress = Memory::AOBScan(gameExecutable, FOVStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 3C92144 - 48 8B 01 - mov rax, [rcx]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3C92147 - FF 90 60 07 00 00 - call qword ptr[rax + 00000760]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3C9214D - F3 0F 10 40 30 - movss xmm0, [rax + 30]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3C92152 - 48 83 C4 28 - add rsp, 28
|
|
//"HellIsUs-Win64-Shipping.exe" + 3C92156 - C3 - ret
|
|
|
|
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 signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(FOVaddress));
|
|
FOVaddress += 0x10;
|
|
}
|
|
}
|
|
|
|
if (Aspectaddress == nullptr) {
|
|
constexpr auto AspectStringObfuscated = make_obfuscated<0x4A>("E9 ?? ?? ?? ?? CC CC CC CC CC CC 48 89 ?? ?? ?? 57 48 83 ?? ?? 0F ?? ?? 48 ?? ?? 48");
|
|
Aspectaddress = Memory::AOBScan(gameExecutable, AspectStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 3453EBA - 89 41 58 - mov[rcx + 58], eax
|
|
//"HellIsUs-Win64-Shipping.exe" + 3453EBD - 8B 42 5C - mov eax, [rdx + 5C]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3453EC0 - 89 41 5C - mov[rcx + 5C], eax <<= Aspect ratio
|
|
//"HellIsUs-Win64-Shipping.exe" + 3453EC3 - 48 8D 42 60 - lea rax, [rdx + 60]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3453EC7 - 48 83 C1 60 - add rcx, 60
|
|
|
|
if (!Aspectaddress)
|
|
logger->warn("Aspect ratio ratio signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
|
|
else {
|
|
logger->info("Aspect ratio signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Aspectaddress));
|
|
Aspectaddress = Aspectaddress + 0x8b;
|
|
}
|
|
}
|
|
|
|
if (DOFaddress == nullptr) {
|
|
constexpr auto DOFStringObfuscated = make_obfuscated<0x4A>("74 ?? 48 ?? ?? 8B ?? ?? 48 ?? ?? E8");
|
|
DOFaddress = Memory::AOBScan(gameExecutable, DOFStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 26ABA27 - 74 03 - je "HellIsUs-Win64-Shipping.exe" + 26ABA2C
|
|
//"HellIsUs-Win64-Shipping.exe" + 26ABA29 - 48 8B C3 - mov rax, rbx
|
|
//"HellIsUs-Win64-Shipping.exe" + 26ABA2C - 8B 34 30 - mov esi, [rax + rsi]
|
|
//"HellIsUs-Win64-Shipping.exe" + 26ABA2F - 48 8B CF - mov rcx, rdi
|
|
//"HellIsUs-Win64-Shipping.exe" + 26ABA32 - E8 D9 C4 6C 01 - call "HellIsUs-Win64-Shipping.exe" + 3D77F10
|
|
|
|
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));
|
|
DOFaddress += 0x5;
|
|
}
|
|
}
|
|
|
|
if (CAaddress == nullptr) {
|
|
constexpr auto CAStringObfuscated = make_obfuscated<0x4A>("7F ?? 44 89 ?? ?? ?? ?? ?? 43 ?? ?? ?? 39 05");
|
|
CAaddress = Memory::AOBScan(gameExecutable, CAStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73BC2 - 48 8B 05 D7 F7 6E 05 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 94633A0]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73BC9 - 44 39 38 - cmp[rax], r15d
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73BCC - 7F 07 - jg "HellIsUs-Win64-Shipping.exe" + 3D73BD5
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73BCE - 44 89 BB 1C 20 00 00 - mov[rbx + 0000201C], r15d
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73BD5 - 43 8B 04 26 - mov eax, [r14 + r12]
|
|
|
|
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 == nullptr) {
|
|
constexpr auto VignettingStringObfuscated = make_obfuscated<0x4A>("8B ?? 83 ?? ?? 7D ?? 44 89");
|
|
Vignettingaddress = Memory::AOBScan(gameExecutable, VignettingStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73C64 - 8B 08 - mov ecx, [rax]
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73C66 - 83 F9 02 - cmp ecx, 02
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73C69 - 7D 09 - jnl "HellIsUs-Win64-Shipping.exe" + 3D73C74
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73C6B - 44 89 BB C8 22 00 00 - mov[rbx + 000022C8], r15d
|
|
//"HellIsUs-Win64-Shipping.exe" + 3D73C72 - EB 05 - jmp "HellIsUs-Win64-Shipping.exe" + 3D73C79
|
|
|
|
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));
|
|
Vignettingaddress += 0x5;
|
|
}
|
|
}
|
|
|
|
if (Fogaddress == nullptr) {
|
|
constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("40 ?? 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 ?? ?? 48 89 ?? ?? ?? 48 8D ?? ?? 48 8D ?? ?? ?? E8");
|
|
Fogaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77C8 - 74 11 - je "HellIsUs-Win64-Shipping.exe" + 22B77DB
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77CA - 48 8B 05 8F 23 08 07 - mov rax, ["HellIsUs-Win64-Shipping.exe" + 9339B60]
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77D1 - 83 78 04 01 - cmp dword ptr[rax + 04], 01
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77D5 - 75 04 - jne "HellIsUs-Win64-Shipping.exe" + 22B77DB
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77D7 - B3 01 - mov bl, 01
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77D9 - EB 02 - jmp "HellIsUs-Win64-Shipping.exe" + 22B77DD
|
|
//"HellIsUs-Win64-Shipping.exe" + 22B77DB - 32 DB - xor bl, bl
|
|
|
|
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));
|
|
Fogaddress += 0x31; // 0x57
|
|
}
|
|
}
|
|
|
|
if (Cameraaddress == nullptr) {
|
|
constexpr auto FogStringObfuscated = make_obfuscated<0x4A>("28 C3 48 83 ?? ?? 48 8B ?? ?? ?? ?? ?? 48 8B ?? 48 85 ?? 75");
|
|
Cameraaddress = Memory::AOBScan(gameExecutable, FogStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 4E9D3F2 - 48 85 C0 - test rax, rax
|
|
//"HellIsUs-Win64-Shipping.exe" + 4E9D3F5 - 74 0A - je "HellIsUs-Win64-Shipping.exe" + 4E9D401
|
|
//"HellIsUs-Win64-Shipping.exe" + 4E9D3F7 - F3 0F 10 40 4C - movss xmm0, [rax + 4C]
|
|
//"HellIsUs-Win64-Shipping.exe" + 4E9D3FC - 48 83 C4 28 - add rsp, 28
|
|
//"HellIsUs-Win64-Shipping.exe" + 4E9D400 - C3 - ret
|
|
|
|
if (!Cameraaddress)
|
|
logger->warn("Camera signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
|
|
else {
|
|
logger->info("Camera signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(Cameraaddress));
|
|
}
|
|
}
|
|
|
|
if (HUDaddress == nullptr) { // Low level function involved in displaying Widgets in real time
|
|
constexpr auto UEConstructStringObfuscated = make_obfuscated<0x4A>("44 0F ?? ?? ?? 74 ?? 48 8B ?? ?? ?? ?? ?? 48 85 ?? 74 ?? 48 8B");
|
|
HUDaddress = Memory::AOBScan(gameExecutable, UEConstructStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
//"HellIsUs-Win64-Shipping.exe" + 1817760 - 0F11 4F 58 - movups[rdi + 58], xmm1
|
|
//"HellIsUs-Win64-Shipping.exe" + 1817764 - 83 BF B8 00 00 00 00 - cmp dword ptr[rdi + HellIsUsCore.dtor_list_head + 88], 00
|
|
//"HellIsUs-Win64-Shipping.exe" + 181776B - 44 0F 10 4F 48 - movups xmm9, [rdi + 48]
|
|
//"HellIsUs-Win64-Shipping.exe" + 1817770 - 44 0F 10 57 58 - movups xmm10, [rdi + 58]
|
|
//"HellIsUs-Win64-Shipping.exe" + 1817775 - 74 36 - je "HellIsUs-Win64-Shipping.exe" + 18177AD
|
|
//"HellIsUs-Win64-Shipping.exe" + 1817777 - 48 8B 8F B0 00 00 00 - mov rcx, [rdi + HellIsUsCore.dtor_list_head + 80]
|
|
|
|
if (!HUDaddress)
|
|
logger->warn("HUD signature not found. Maybe your game has been updated and is no more compatible with this plugin.");
|
|
else {
|
|
logger->info("HUD signature found at address: 0x{:X}.", reinterpret_cast<uintptr_t>(HUDaddress));
|
|
HUDaddress += 0x05;
|
|
}
|
|
}
|
|
|
|
if (Aspectaddress && DOFaddress && CAaddress && Vignettingaddress && Fogaddress && Cameraaddress) {
|
|
logger->info("All AOB signatures found. Ready to patch...");
|
|
AOBScanDone = true;
|
|
}
|
|
|
|
if (!GObjectsaddress || !AppendStringaddress || !ProcessEventaddress) {
|
|
logger->info("------------ UEngine offsets search ------------");
|
|
|
|
constexpr auto GObjetcsStringObfuscated = make_obfuscated<0x4A>("48 8B ?? ?? ?? ?? ?? 48 8B ?? ?? 48 8D ?? ?? EB ?? 33");
|
|
GObjectsaddress = Memory::AOBScan(gameExecutable, GObjetcsStringObfuscated.decrypt(), PAGE_EXECUTE_READ);
|
|
constexpr auto AppendStringStringObfuscated = make_obfuscated<0x4A>("48 89 ?? ?? ?? 48 89 ?? ?? ?? 57 48 83 ?? ?? 80 3D ?? ?? ?? ?? ?? 48 8B F2 8B ?? 48");
|
|
AppendStringaddress = Memory::AOBScan(gameExecutable, 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 ?? ?? ?? ?? ?? 4D ?? ?? 48");
|
|
ProcessEventaddress = Memory::AOBScan(gameExecutable, 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) -
|
|
reinterpret_cast<uint8_t*>(GetModuleHandleA(gameExecutable.c_str())));
|
|
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(gameExecutable, AppendStringaddress); // Get Offset from opcode
|
|
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(gameExecutable, 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 && Aspectaddress) AspectFixEnabled();
|
|
if (!init && Cameraaddress) CameraFixEnabled(ECharlieCameraMode::Camera);
|
|
if (!init && Cameraaddress) CameraFixEnabled(ECharlieCameraMode::FOV);
|
|
if (!init && DOFaddress) DOFFixEnabled();
|
|
if (!init && CAaddress) CAFixEnabled();
|
|
if (!init && Vignettingaddress) VignettingFixEnabled();
|
|
if (!init && Fogaddress) FogFixEnabled();
|
|
if (!init && GObjectsaddress && AppendStringaddress && ProcessEventaddress && HUDaddress)
|
|
HUDFixEnabled();
|
|
}
|
|
|
|
// Setters for Reshade addon call
|
|
extern "C" __declspec(dllexport) void SetFixesEnabled(GameFixes fix, bool enabled) {
|
|
if (fix == GameFixes::DevConsole) { g_Console = enabled; EnableConsole(); };
|
|
if (fix == GameFixes::FOV) { g_fov_fix_enabled = enabled; FOVFixEnabled(); CameraFixEnabled(ECharlieCameraMode::FOV); }
|
|
if (fix == GameFixes::UltraWide) { g_aspect_fix_enabled = enabled; AspectFixEnabled(); }
|
|
if (fix == GameFixes::Camera) { g_Camera_fix_enabled = enabled; CameraFixEnabled(ECharlieCameraMode::Camera); };
|
|
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(); }
|
|
if (fix == GameFixes::HUD) { g_HUD_fix_enabled = enabled; HUDFixEnabled(); }
|
|
}
|
|
|
|
extern "C" __declspec(dllexport) void SetFOV(int fov)
|
|
{
|
|
g_AdditionalFOVValue = fov;
|
|
}
|
|
|
|
extern "C" __declspec(dllexport) void SetCameraDistance(float cameraDistance)
|
|
{
|
|
g_cameraDistanceMultiplier = cameraDistance;
|
|
}
|
|
|
|
extern "C" __declspec(dllexport) void SetCameraHeight(int cameraHeight)
|
|
{
|
|
g_cameraHeight = (float)cameraHeight;
|
|
}
|
|
|
|
extern "C" __declspec(dllexport) void SetHUD(int HUDValue)
|
|
{
|
|
float percentageLeft = (float)HUDValue / 100;
|
|
float percentageRight = 1 - (float)HUDValue / 100;
|
|
HUDAnchors = { { percentageLeft , 0.f }, { percentageRight , 1.f} };
|
|
}
|
|
|
|
// Getters for Reshade addon call
|
|
extern "C" __declspec(dllexport) void GetGameInfos(GameInfos* infos) {
|
|
if (!infos) return;
|
|
|
|
infos->FOVIn = g_FOV_In;
|
|
infos->CompensatedFOV = g_Compensated_FOV;
|
|
infos->FOVOut = g_FOV_Out;
|
|
infos->cameraIn = g_Camera_In;
|
|
infos->cameraOut = g_Camera_Out;
|
|
infos->consoleEnabled = g_Console_Enabled;
|
|
}
|
|
|
|
// Code injection functions
|
|
// FOV compensation only
|
|
static void FOVFixEnabled() {
|
|
if (FOVaddress) {
|
|
if (!FOVHook) { // Hook only once
|
|
FOVHook = safetyhook::create_mid(FOVaddress,
|
|
[](SafetyHookContext& ctx) {
|
|
g_FOV_In = ctx.xmm0.f32[0];
|
|
g_Compensated_FOV = ctx.xmm0.f32[0];
|
|
if (g_fix_enabled && g_aspect_fix_enabled)
|
|
g_Compensated_FOV = ctx.xmm0.f32[0] = Maths::CompensateHorizontalFOV(g_FOV_In, BASE_ASPECT, aspectRatio);
|
|
g_FOV_Out = ctx.xmm0.f32[0];
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AspectFixEnabled() {
|
|
if (g_fix_enabled && g_aspect_fix_enabled && Aspectaddress) {
|
|
if (!AspectHook) {
|
|
AspectHook = safetyhook::create_mid(Aspectaddress,
|
|
[](SafetyHookContext& ctx) {
|
|
ctx.rax = *reinterpret_cast<uint32_t*>(&aspectRatio);
|
|
});
|
|
}
|
|
else AspectHook.enable();
|
|
FOVFixEnabled();
|
|
logger->info("Aspect fix enabled");
|
|
}
|
|
if (!(g_fix_enabled && g_aspect_fix_enabled)) {
|
|
if (AspectHook) AspectHook.disable();
|
|
logger->info("Aspect ratio fix disabled");
|
|
}
|
|
}
|
|
// Controls FOV & camera height & distance
|
|
static void CameraFixEnabled(ECharlieCameraMode mode) {
|
|
if (Cameraaddress) {
|
|
if (!CameraHook) { // Hook only once +0x4e or start to test +0x13
|
|
CameraHook = safetyhook::create_mid(Cameraaddress + 0x4e,
|
|
[](SafetyHookContext& ctx) {
|
|
g_Camera_In = ctx.xmm0.f32[0];
|
|
ctx.xmm0.f32[0] *= (g_Camera_fix_enabled ? g_cameraDistanceMultiplier : 1.f);
|
|
g_Camera_Out = ctx.xmm0.f32[0];
|
|
|
|
// Retrieve player camera object
|
|
auto* charlieCameraBaseConfig = reinterpret_cast<UCharlieCameraBaseConfig*>(ctx.rax);
|
|
if (charlieCameraBaseConfig && charlieCameraBaseConfig->IsA(UCharlieCameraBaseConfig::StaticClass())) {
|
|
// Camera height
|
|
charlieCameraBaseConfig->DefaultHeightFromPlayer = g_fix_enabled && g_Camera_fix_enabled ? g_cameraHeight : DEFAULT_CAMERA_HEIGHT;
|
|
// World FOV
|
|
charlieCameraBaseConfig->FieldOfView = DEFAULT_WORLD_FOV
|
|
+ g_fix_enabled && g_fov_fix_enabled ? g_AdditionalFOVValue : 0.f;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (mode == ECharlieCameraMode::Camera) {
|
|
if (g_Camera_fix_enabled) logger->info("Camera fix enabled");
|
|
else logger->info("Camera fix disabled");
|
|
}
|
|
if (mode == ECharlieCameraMode::FOV) {
|
|
if (g_fov_fix_enabled) logger->info("FOV fix enabled");
|
|
else logger->info("FOV fix disabled");
|
|
}
|
|
}
|
|
|
|
static void HUDFixEnabled() {
|
|
if (ProcessEventaddress && HUDaddress) {
|
|
if (!HUDProcessEventHook) {
|
|
HUDProcessEventHook = safetyhook::create_mid(ProcessEventaddress + 0xc,
|
|
[](SafetyHookContext& ctx) {
|
|
auto* object = reinterpret_cast<UObject*>(ctx.rcx);
|
|
auto* function = reinterpret_cast<UFunction*>(ctx.rdx);
|
|
// Filter object on Unreal User widgets
|
|
if (object && object->IsA(UUserWidget::StaticClass()) && function) {
|
|
std::string funcName = function->GetName();
|
|
std::string objectName = object->GetName();
|
|
// Filter by function construct
|
|
if (funcName == "Construct") {
|
|
auto* objectClass = object->Class;
|
|
std::string className = objectClass ? objectClass->GetName() : "Unknown";
|
|
auto* widget = static_cast<UUserWidget*>(object);
|
|
// Ensure the widget is of UCanvasPanelSlot & valid
|
|
if (widget && widget->Slot && widget->Slot->IsA(UCanvasPanelSlot::StaticClass())) {
|
|
auto* canvasSlot = static_cast<UCanvasPanelSlot*>(widget->Slot);
|
|
|
|
// Filter on class drawing HUD in game
|
|
if (canvasSlot && className.contains("CombatHud_SUMG_C"))
|
|
canvasSlot->SetAnchors(referenceHUDAnchors);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if (!HUDHook) {
|
|
HUDHook = safetyhook::create_mid(HUDaddress,
|
|
[](SafetyHookContext& ctx) {
|
|
if (ctx.xmm9.f64[0] == referenceHUDAnchors.Minimum.X && ctx.xmm9.f64[1] == referenceHUDAnchors.Minimum.Y &&
|
|
ctx.xmm10.f64[0] == referenceHUDAnchors.Maximum.X && ctx.xmm10.f64[1] == referenceHUDAnchors.Maximum.Y) {
|
|
// Comparison between reference anchors previously set and the one retrieved here
|
|
// This is to ensure the right Widget is targeted (CombatHud_SUMG_C)
|
|
if (g_fix_enabled && g_HUD_fix_enabled) {
|
|
ctx.xmm9.f64[0] = HUDAnchors.Minimum.X; ctx.xmm9.f64[1] = HUDAnchors.Minimum.Y;
|
|
ctx.xmm10.f64[0] = HUDAnchors.Maximum.X; ctx.xmm10.f64[1] = HUDAnchors.Maximum.Y;
|
|
}
|
|
else {
|
|
ctx.xmm9.f64[0] = defaultHUDAnchors.Minimum.X; ctx.xmm9.f64[1] = defaultHUDAnchors.Minimum.Y;
|
|
ctx.xmm10.f64[0] = defaultHUDAnchors.Maximum.X; ctx.xmm10.f64[1] = defaultHUDAnchors.Maximum.Y;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if (g_fix_enabled && g_HUD_fix_enabled)
|
|
logger->info("HUD fix enabled");
|
|
else logger->info("HUD fix disabled");
|
|
|
|
}
|
|
}
|
|
|
|
// Memory patch fixes
|
|
static void DOFFixEnabled() {
|
|
if (g_fix_enabled && g_DOF_fix_enabled && DOFaddress) {
|
|
Memory::PatchBytes(DOFaddress, "\x31\xF6\x90", 3); // xor esi,esi 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() {
|
|
if (g_fix_enabled && g_CA_fix_enabled && CAaddress) {
|
|
Memory::PatchBytes(CAaddress, "\x90\x90", 2); // NOP jg "HellIsUs-Win64-Shipping.exe"+3D73BD5
|
|
logger->info("Chromatics aberrations fix enabled");
|
|
}
|
|
if (!(g_fix_enabled && g_CA_fix_enabled) && CAaddress) {
|
|
Memory::RestoreBytes(CAaddress);
|
|
logger->info("Chromatics aberrations fix disabled");
|
|
}
|
|
}
|
|
|
|
static void VignettingFixEnabled() {
|
|
if (g_fix_enabled && g_Vignetting_fix_enabled && Vignettingaddress) {
|
|
Memory::PatchBytes(Vignettingaddress, "\x31\xC9", 2); // xor ecx,ecx r.Tonemapper.Quality=0
|
|
logger->info("Vignetting fix enabled");
|
|
}
|
|
if (!(g_fix_enabled && g_Vignetting_fix_enabled) && Vignettingaddress) {
|
|
Memory::RestoreBytes(Vignettingaddress);
|
|
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");
|
|
}
|
|
|
|
// UE Console creation
|
|
static void EnableConsole()
|
|
{
|
|
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);
|
|
// Compute console enabling duration
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
std::chrono::duration<double> elapsed = end - start;
|
|
|
|
// Set the all the console shortkey to F2
|
|
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>("Hell Is Us", 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;
|
|
} |