Implement universal addresses

cmake/pch.hpp.in

@@ -31,7 +31,3 @@
 #include <vector>
 
 #include <Windows.h>
-
-#include <RED4ext/Addresses.hpp>
-#include <RED4ext/Common.hpp>
-#include <RED4ext/Relocation.hpp>

include/RED4ext/CNamePool-inl.hpp

@@ -4,15 +4,15 @@
 #include <RED4ext/CNamePool.hpp>
 #endif
 
-#include <RED4ext/Addresses.hpp>
+#include <RED4ext/Detail/AddressHashes.hpp>
 #include <RED4ext/Common.hpp>
 #include <RED4ext/Relocation.hpp>
 
 RED4EXT_INLINE RED4ext::CName RED4ext::CNamePool::Add(const char* aText)
 {
     CName result;
 
-    RelocFunc<CName* (*)(CName&, const char*)> func(Addresses::CNamePool_AddCstr);
+    UniversalRelocFunc<CName* (*)(CName&, const char*)> func(Detail::AddressHashes::CNamePool_AddCstr);
     func(result, aText);
     return result;
 }
@@ -21,14 +21,14 @@ RED4EXT_INLINE RED4ext::CName RED4ext::CNamePool::Add(const CString& aText)
 {
     CName result;
 
-    RelocFunc<CName* (*)(CName&, const CString&)> func(Addresses::CNamePool_AddCString);
+    UniversalRelocFunc<CName* (*)(CName&, const CString&)> func(Detail::AddressHashes::CNamePool_AddCString);
     func(result, aText);
     return result;
 }
 
 RED4EXT_INLINE void RED4ext::CNamePool::Add(const CName& aName, const char* aText)
 {
-    RelocFunc<uint8_t (*)(const CName&, const char*)> func(Addresses::CNamePool_AddPair);
+    UniversalRelocFunc<uint8_t (*)(const CName&, const char*)> func(Detail::AddressHashes::CNamePool_AddPair);
     func(aName, aText);
 }
 
@@ -39,7 +39,7 @@ RED4EXT_INLINE void RED4ext::CNamePool::Add(const CName& aName, const CString& a
 
 RED4EXT_INLINE const char* RED4ext::CNamePool::Get(const CName& aName)
 {
-    RelocFunc<const char* (*)(const CName&)> func(Addresses::CNamePool_Get);
+    UniversalRelocFunc<const char* (*)(const CName&)> func(Detail::AddressHashes::CNamePool_Get);
     auto result = func(aName);
     if (result)
     {

include/RED4ext/CString-inl.hpp

@@ -6,7 +6,7 @@
 
 #include <cstring>
 
-#include <RED4ext/Addresses.hpp>
+#include <RED4ext/Detail/AddressHashes.hpp>
 #include <RED4ext/Relocation.hpp>
 
 RED4EXT_INLINE RED4ext::CString::CString(Memory::IAllocator* aAllocator)
@@ -19,41 +19,41 @@ RED4EXT_INLINE RED4ext::CString::CString(Memory::IAllocator* aAllocator)
 RED4EXT_INLINE RED4ext::CString::CString(const char* aText, Memory::IAllocator* aAllocator)
     : CString(aAllocator)
 {
-    RelocFunc<CString* (*)(CString*, const char*)> func(Addresses::CString_ctor_str);
+    UniversalRelocFunc<CString* (*)(CString*, const char*)> func(Detail::AddressHashes::CString_ctor_str);
     func(this, aText);
 }
 
 RED4EXT_INLINE RED4ext::CString::CString(const char* aText, uint32_t aLength, Memory::IAllocator* aAllocator)
     : CString(aAllocator)
 {
-    RelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Addresses::CString_ctor_span);
+    UniversalRelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Detail::AddressHashes::CString_ctor_span);
     func(this, aText, aLength);
 }
 
 RED4EXT_INLINE RED4ext::CString::CString(const std::string& aText, Memory::IAllocator* aAllocator)
     : CString(aAllocator)
 {
-    RelocFunc<CString* (*)(CString*, const char*)> func(Addresses::CString_ctor_str);
+    UniversalRelocFunc<CString* (*)(CString*, const char*)> func(Detail::AddressHashes::CString_ctor_str);
     func(this, aText.data());
 }
 
 RED4EXT_INLINE RED4ext::CString::CString(const std::string_view& aText, Memory::IAllocator* aAllocator)
     : CString(aAllocator)
 {
-    RelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Addresses::CString_ctor_span);
+    UniversalRelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Detail::AddressHashes::CString_ctor_span);
     func(this, aText.data(), static_cast<uint32_t>(aText.size()));
 }
 
 RED4EXT_INLINE RED4ext::CString::CString(const CString& aOther)
     : CString()
 {
-    RelocFunc<CString* (*)(CString*, const CString&)> func(Addresses::CString_copy);
+    UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
     func(this, aOther);
 }
 
 RED4EXT_INLINE RED4ext::CString::~CString()
 {
-    RelocFunc<CString* (*)(CString*)> func(Addresses::CString_dtor);
+    UniversalRelocFunc<CString* (*)(CString*)> func(Detail::AddressHashes::CString_dtor);
     func(this);
 }
 
@@ -70,7 +70,7 @@ RED4EXT_INLINE RED4ext::CString::CString(CString&& aOther) noexcept
 
 RED4EXT_INLINE RED4ext::CString& RED4ext::CString::operator=(const CString& aRhs)
 {
-    RelocFunc<CString* (*)(CString*, const CString&)> func(Addresses::CString_copy);
+    UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
     func(this, aRhs);
     return *this;
 }

include/RED4ext/Detail/AddressHashes.hpp

@@ -0,0 +1,198 @@
+#pragma once
+
+#include <cstdint>
+
+#include <RED4ext/Hashing/FNV1a.hpp>
+
+// clang-format off
+namespace RED4ext::Detail::AddressHashes
+{
+#pragma region CBaseFunction
+constexpr std::uint64_t CBaseFunction_Handlers = RED4ext::FNV1a64("CBaseFunction_Handlers");
+constexpr std::uint64_t CBaseFunction_ExecuteScripted = 0xE1F920D6;
+constexpr std::uint64_t CBaseFunction_ExecuteNative = 0xE1321AEB;
+constexpr std::uint64_t CBaseFunction_InternalExecute = 0x1817231D;
+#pragma endregion
+
+#pragma region CBaseRTTIType
+constexpr std::uint64_t CBaseRTTIType_sub_80 = 0xE46F169E;
+constexpr std::uint64_t CBaseRTTIType_sub_88 = 0x15BE1744;
+constexpr std::uint64_t CBaseRTTIType_sub_90 = 0xA45935A1;
+constexpr std::uint64_t CBaseRTTIType_sub_98 = 0xAEA91F1D;
+constexpr std::uint64_t CBaseRTTIType_sub_A0 = 0x8ED61BC2;
+#pragma endregion
+
+#pragma region CBitfield
+constexpr std::uint64_t CBitfield_Unserialize = 0xA6981914;
+constexpr std::uint64_t CBitfield_ToString = 0x54231404;
+constexpr std::uint64_t CBitfield_FromString = 0xA09B15A8;
+#pragma endregion
+
+#pragma region CClass
+constexpr std::uint64_t CClass_Unserialize = 0xE4AA0CAD;
+constexpr std::uint64_t CClass_ToString = 0x65293F06;
+constexpr std::uint64_t CClass_sub_80 = 0x11D11B0C;
+constexpr std::uint64_t CClass_sub_88 = 0x4BDF1BB2;
+constexpr std::uint64_t CClass_sub_90 = 0xA26D374E;
+constexpr std::uint64_t CClass_sub_98 = 0x48C020CA;
+constexpr std::uint64_t CClass_sub_A0 = 0x15F21D6F;
+constexpr std::uint64_t CClass_sub_B0 = 0xA0911974;
+constexpr std::uint64_t CClass_sub_C0 = 0x7DD010C3;
+constexpr std::uint64_t CClass_GetMaxAlignment = 0xD14E1230;
+constexpr std::uint64_t CClass_sub_D0 = 0x37750EBF;
+constexpr std::uint64_t CClass_CreateInstance = 0x5A800F1D;
+constexpr std::uint64_t CClass_GetProperty = 0x8F031512;
+constexpr std::uint64_t CClass_GetProperties = 0xB412121B;
+constexpr std::uint64_t CClass_ClearScriptedData = 0x31F20E93;
+constexpr std::uint64_t CClass_InitializeProperties = 0xF4AC12B0;
+constexpr std::uint64_t CClass_AssignDefaultValuesToProperties = 0x97DF1590;
+#pragma endregion
+
+#pragma region CClassFunction
+constexpr std::uint64_t CClassFunction_ctor = 0x602D29F3;
+#pragma endregion
+
+#pragma region CClassStaticFunction
+constexpr std::uint64_t CClassStaticFunction_ctor = 0x235013BB;
+#pragma endregion
+
+#pragma region CEnum
+constexpr std::uint64_t CEnum_Unserialize = 0x40D317A6;
+constexpr std::uint64_t CEnum_ToString = 0x41A1296;
+constexpr std::uint64_t CEnum_FromString = 0x21CA1EC1;
+#pragma endregion
+
+#pragma region CGameEngine
+constexpr std::uint64_t CGameEngine = RED4ext::FNV1a64("CGameEngine");
+#pragma endregion
+
+#pragma region CGlobalFunction
+constexpr std::uint64_t CGlobalFunction_ctor = 0xFA6B24D0;
+#pragma endregion
+
+#pragma region CNamePool
+constexpr std::uint64_t CNamePool_AddCstr = 0xA00C9B;
+constexpr std::uint64_t CNamePool_AddCString = 0xFFD61709;
+constexpr std::uint64_t CNamePool_AddPair = 0xD9840BD8;
+constexpr std::uint64_t CNamePool_Get = 0x68DF07DC;
+#pragma endregion
+
+#pragma region CRTTIRegistrator
+constexpr std::uint64_t CRTTIRegistrator_RTTIAsyncId = RED4ext::FNV1a64("CRTTIRegistrator_RTTIAsyncId");
+#pragma endregion
+
+#pragma region CRTTIScriptReferenceType
+constexpr std::uint64_t CRTTIScriptReferenceType_ctor = 0xCB8A115C;
+constexpr std::uint64_t CRTTIScriptReferenceType_Set = 0x22EE172F;
+#pragma endregion
+
+#pragma region CRTTISystem
+constexpr std::uint64_t CRTTISystem_Get = 0x4A610F64;
+#pragma endregion
+
+#pragma region CStack
+constexpr std::uint64_t CStack_vtbl = RED4ext::FNV1a64("CStack_vtbl");
+#pragma endregion
+
+#pragma region CString
+constexpr std::uint64_t CString_ctor_str = 0xC81F0AAB;
+constexpr std::uint64_t CString_ctor_span = 0x7B210877;
+constexpr std::uint64_t CString_copy = 0xE8B40B51;
+constexpr std::uint64_t CString_dtor = 0x5405072C;
+#pragma endregion
+
+#pragma region DynArray
+constexpr std::uint64_t DynArray_Realloc = 0x7AA013D2;
+#pragma endregion
+
+#pragma region Handle
+constexpr std::uint64_t Handle_ctor = 0xBA0C115D;
+constexpr std::uint64_t Handle_DecWeakRef = 0x333B1404;
+#pragma endregion
+
+#pragma region IScriptable
+constexpr std::uint64_t IScriptable_sub_D8 = 0xF8E41DDF;
+constexpr std::uint64_t IScriptable_DestructValueHolder = 0x3521331;
+#pragma endregion
+
+#pragma region ISerializable
+constexpr std::uint64_t ISerializable_sub_30 = 0x6D63649;
+constexpr std::uint64_t ISerializable_sub_40 = 0x88B30FF9;
+constexpr std::uint64_t ISerializable_sub_78 = 0xA1D93993;
+constexpr std::uint64_t ISerializable_sub_A0 = 0xED221B32;
+constexpr std::uint64_t ISerializable_sub_C0 = 0x80201C35;
+#pragma endregion
+
+#pragma region JobDispatcher
+constexpr std::uint64_t JobDispatcher = RED4ext::FNV1a64("JobDispatcher");
+constexpr std::uint64_t JobDispatcher_DispatchJob = 0x9C441E82;
+#pragma endregion
+
+#pragma region JobHandle
+constexpr std::uint64_t JobHandle_ctor = 0x6EFF1BD2;
+constexpr std::uint64_t JobHandle_dtor = 0x9E480A2E;
+constexpr std::uint64_t JobHandle_Join = 0x9C9C097C;
+#pragma endregion
+
+#pragma region JobQueue
+constexpr std::uint64_t JobQueue_ctor_FromGroup = 0xE750D4B;
+constexpr std::uint64_t JobQueue_ctor_FromParams = 0x82BD14F8;
+constexpr std::uint64_t JobQueue_dtor = 0x5AF4077C;
+constexpr std::uint64_t JobQueue_Capture = 0x41D12C4;
+constexpr std::uint64_t JobQueue_SyncWait = 0xD9AD0C00;
+#pragma endregion
+
+#pragma region Memory
+constexpr std::uint64_t Memory_Vault = RED4ext::FNV1a64("Memory_Vault");
+constexpr std::uint64_t Memory_Vault_Alloc = 0x902A14E0;
+constexpr std::uint64_t Memory_Vault_AllocAligned = 0x516917DD;
+constexpr std::uint64_t Memory_Vault_Realloc = 0x770A17AC;
+constexpr std::uint64_t Memory_Vault_ReallocAligned = 0x56961AA9;
+constexpr std::uint64_t Memory_Vault_Free = 0x33421332;
+constexpr std::uint64_t Memory_Vault_Unk1 = 0x19EC1367;
+constexpr std::uint64_t Memory_PoolStorage_OOM = 0xD54F163A;
+#pragma endregion
+
+#pragma region OpcodeHandlers
+constexpr std::uint64_t OpcodeHandlers = RED4ext::FNV1a64("OpcodeHandlers");
+#pragma endregion
+
+#pragma region ResourceDepot
+constexpr std::uint64_t ResourceDepot = RED4ext::FNV1a64("ResourceDepot");
+#pragma endregion
+
+#pragma region ResourceLoader
+constexpr std::uint64_t ResourceLoader = RED4ext::FNV1a64("ResourceLoader");
+constexpr std::uint64_t ResourceLoader_FindTokenFast = 0xC86F39B7;
+constexpr std::uint64_t ResourceLoader_LoadAsync = 0x4A863580;
+#pragma endregion
+
+#pragma region ResourceReference
+constexpr std::uint64_t ResourceReference_Load = 0xEB0DA9;
+constexpr std::uint64_t ResourceReference_Fetch = 0xB69D158E;
+constexpr std::uint64_t ResourceReference_Reset = 0x2308246B;
+#pragma endregion
+
+#pragma region ResourceToken
+constexpr std::uint64_t ResourceToken_dtor = 0x9A5F0A0D;
+constexpr std::uint64_t ResourceToken_Fetch = 0x8C0918CA;
+constexpr std::uint64_t ResourceToken_OnLoaded = 0xEB4B25AB;
+constexpr std::uint64_t ResourceToken_CancelUnk38 = 0xF6E20CE6;
+constexpr std::uint64_t ResourceToken_DestructUnk38 = 0x95831FEE;
+#pragma endregion
+
+#pragma region TTypedClass
+constexpr std::uint64_t TTypedClass_IsEqual = 0x58630EE8;
+#pragma endregion
+
+#pragma region TweakDB
+constexpr std::uint64_t TweakDB_Get = 0x36800DE4;
+constexpr std::uint64_t TweakDB_CreateRecord = 0x3201127A;
+#pragma endregion
+
+#pragma region UpdateRegistrar
+constexpr std::uint64_t UpdateRegistrar_RegisterGroupUpdate = 0xFD914605;
+constexpr std::uint64_t UpdateRegistrar_RegisterBucketUpdate = 0x192F4EA2;
+#pragma endregion
+}
+// clang-format on

include/RED4ext/DynArray.hpp

@@ -5,7 +5,7 @@
 #include <functional>
 #include <type_traits>
 
-#include <RED4ext/Addresses.hpp>
+#include <RED4ext/Detail/AddressHashes.hpp>
 #include <RED4ext/Common.hpp>
 #include <RED4ext/Relocation.hpp>
 #include <RED4ext/Utils.hpp>
@@ -188,7 +188,7 @@ struct DynArray
         using func_t = void (*)(DynArray * aThis, uint32_t aCapacity, uint32_t aElementSize, uint32_t aAlignment,
                                 void (*a5)(int64_t, int64_t, int64_t, int64_t));
 
-        RelocFunc<func_t> func(Addresses::DynArray_Realloc);
+        UniversalRelocFunc<func_t> func(Detail::AddressHashes::DynArray_Realloc);
         func(this, newCapacity, sizeof(T), alignment, nullptr);
     }
 

include/RED4ext/GameEngine-inl.hpp

@@ -4,11 +4,11 @@
 #include <RED4ext/GameEngine.hpp>
 #endif
 
-#include <RED4ext/Addresses.hpp>
+#include <RED4ext/Detail/AddressHashes.hpp>
 #include <RED4ext/Relocation.hpp>
 
 RED4EXT_INLINE RED4ext::CGameEngine* RED4ext::CGameEngine::Get()
 {
-    RelocPtr<CGameEngine*> ptr(Addresses::CGameEngine);
+    UniversalRelocPtr<CGameEngine*> ptr(Detail::AddressHashes::CGameEngine);
     return ptr;
 }

include/RED4ext/Handle.hpp

@@ -2,7 +2,7 @@
 
 #include <type_traits>
 
-#include <RED4ext/Addresses.hpp>
+#include <RED4ext/Detail/AddressHashes.hpp>
 #include <RED4ext/Memory/SharedPtr.hpp>
 #include <RED4ext/Relocation.hpp>
 
@@ -26,7 +26,7 @@ class Handle : public SharedPtrWithAccess<T>
 
     explicit Handle(T* aPtr)
     {
-        RelocFunc<Handle* (*)(Handle*, T*)> ctor(Addresses::Handle_ctor);
+        UniversalRelocFunc<Handle* (*)(Handle*, T*)> ctor(Detail::AddressHashes::Handle_ctor);
         ctor(this, aPtr);
     }