Merge pull request #110 from psiberx/master

Fix addresses

include/RED4ext/CNamePool-inl.hpp

@@ -12,7 +12,7 @@ RED4EXT_INLINE RED4ext::CName RED4ext::CNamePool::Add(const char* aText)
 {
     CName result;
 
-    UniversalRelocFunc<CName* (*)(CName&, const char*)> func(Detail::AddressHashes::CNamePool_AddCstr);
+    static 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;
 
-    UniversalRelocFunc<CName* (*)(CName&, const CString&)> func(Detail::AddressHashes::CNamePool_AddCString);
+    static 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)
 {
-    UniversalRelocFunc<uint8_t (*)(const CName&, const char*)> func(Detail::AddressHashes::CNamePool_AddPair);
+    static 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)
 {
-    UniversalRelocFunc<const char* (*)(const CName&)> func(Detail::AddressHashes::CNamePool_Get);
+    static UniversalRelocFunc<const char* (*)(const CName&)> func(Detail::AddressHashes::CNamePool_Get);
     auto result = func(aName);
     if (result)
     {

include/RED4ext/CString-inl.hpp

@@ -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)
 {
-    UniversalRelocFunc<CString* (*)(CString*, const char*)> func(Detail::AddressHashes::CString_ctor_str);
+    static 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)
 {
-    UniversalRelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Detail::AddressHashes::CString_ctor_span);
+    static 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)
 {
-    UniversalRelocFunc<CString* (*)(CString*, const char*)> func(Detail::AddressHashes::CString_ctor_str);
+    static 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)
 {
-    UniversalRelocFunc<CString* (*)(CString*, const char*, uint32_t)> func(Detail::AddressHashes::CString_ctor_span);
+    static 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()
 {
-    UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
+    static UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
     func(this, aOther);
 }
 
 RED4EXT_INLINE RED4ext::CString::~CString()
 {
-    UniversalRelocFunc<CString* (*)(CString*)> func(Detail::AddressHashes::CString_dtor);
+    static 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)
 {
-    UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
+    static UniversalRelocFunc<CString* (*)(CString*, const CString&)> func(Detail::AddressHashes::CString_copy);
     func(this, aRhs);
     return *this;
 }

include/RED4ext/Detail/AddressHashes.hpp

@@ -37,12 +37,12 @@ constexpr std::uint32_t CClass_sub_90 = 0xA26D374E;
 constexpr std::uint32_t CClass_sub_98 = 0x48C020CA;
 constexpr std::uint32_t CClass_sub_A0 = 0x15F21D6F;
 constexpr std::uint32_t CClass_sub_B0 = 0xA0911974;
-constexpr std::uint32_t CClass_sub_C0 = 0x7DD010C3;
+constexpr std::uint32_t CClass_sub_C0 = 3523744305UL;
 constexpr std::uint32_t CClass_GetMaxAlignment = 0xD14E1230;
 constexpr std::uint32_t CClass_sub_D0 = 0x37750EBF;
 constexpr std::uint32_t CClass_CreateInstance = 0x5A800F1D;
 constexpr std::uint32_t CClass_GetProperty = 0x8F031512;
-constexpr std::uint32_t CClass_GetProperties = 0xB412121B;
+constexpr std::uint32_t CClass_GetProperties = 1652956141UL;
 constexpr std::uint32_t CClass_ClearScriptedData = 0x31F20E93;
 constexpr std::uint32_t CClass_InitializeProperties = 0xF4AC12B0;
 constexpr std::uint32_t CClass_AssignDefaultValuesToProperties = 0x97DF1590;
@@ -124,7 +124,7 @@ constexpr std::uint32_t ISerializable_sub_C0 = 0x80201C35;
 #pragma endregion
 
 #pragma region JobDispatcher
-constexpr std::uint32_t JobDispatcher = 0xBAD50B3D;
+constexpr std::uint32_t JobDispatcher = 1508445968UL;
 constexpr std::uint32_t JobDispatcher_DispatchJob = 0x9C441E82;
 #pragma endregion
 

include/RED4ext/DynArray.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));
 
-        UniversalRelocFunc<func_t> func(Detail::AddressHashes::DynArray_Realloc);
+        static UniversalRelocFunc<func_t> func(Detail::AddressHashes::DynArray_Realloc);
         func(this, newCapacity, sizeof(T), alignment, nullptr);
     }
 

include/RED4ext/GameEngine-inl.hpp

@@ -9,6 +9,6 @@
 
 RED4EXT_INLINE RED4ext::CGameEngine* RED4ext::CGameEngine::Get()
 {
-    UniversalRelocPtr<CGameEngine*> ptr(Detail::AddressHashes::CGameEngine);
+    static UniversalRelocPtr<CGameEngine*> ptr(Detail::AddressHashes::CGameEngine);
     return ptr;
 }

include/RED4ext/Handle.hpp

@@ -26,7 +26,7 @@ class Handle : public SharedPtrWithAccess<T>
 
     explicit Handle(T* aPtr)
     {
-        UniversalRelocFunc<Handle* (*)(Handle*, T*)> ctor(Detail::AddressHashes::Handle_ctor);
+        static UniversalRelocFunc<Handle* (*)(Handle*, T*)> ctor(Detail::AddressHashes::Handle_ctor);
         ctor(this, aPtr);
     }
 

include/RED4ext/ISerializable-inl.hpp

@@ -29,7 +29,7 @@ RED4EXT_INLINE void RED4ext::ISerializable::sub_28()
 RED4EXT_INLINE bool RED4ext::ISerializable::sub_30()
 {
     using func_t = bool (*)(ISerializable*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_30);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_30);
     return func(this);
 }
 
@@ -40,7 +40,7 @@ RED4EXT_INLINE void RED4ext::ISerializable::sub_38()
 RED4EXT_INLINE bool RED4ext::ISerializable::sub_40(BaseStream* aStream)
 {
     using func_t = bool (*)(ISerializable*, BaseStream*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_40);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_40);
     return func(this, aStream);
 }
 
@@ -79,7 +79,7 @@ RED4EXT_INLINE bool RED4ext::ISerializable::sub_70()
 RED4EXT_INLINE int64_t RED4ext::ISerializable::sub_78(int64_t a1, int64_t a2, uint8_t a3, int64_t a4, int64_t a5)
 {
     using func_t = int64_t (*)(ISerializable*, int64_t, int64_t, uint8_t, int64_t, int64_t);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_78);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_78);
     return func(this, a1, a2, a3, a4, a5);
 }
 
@@ -106,7 +106,7 @@ RED4EXT_INLINE void* RED4ext::ISerializable::sub_A0()
 {
     // This is an allocation, but for what?
     using func_t = void* (*)(ISerializable*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_A0);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_A0);
     return func(this);
 }
 
@@ -131,7 +131,7 @@ RED4EXT_INLINE RED4ext::CString RED4ext::ISerializable::sub_B8()
 RED4EXT_INLINE void* RED4ext::ISerializable::sub_C0(void* a1)
 {
     using func_t = void* (*)(ISerializable*, void*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_C0);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::ISerializable_sub_C0);
     return func(this, a1);
 }
 

include/RED4ext/JobQueue-inl.hpp

@@ -42,47 +42,47 @@ RED4EXT_INLINE RED4ext::JobParamSet::JobParamSet() noexcept
 RED4EXT_INLINE RED4ext::JobHandle::JobHandle(uintptr_t aUnk)
 {
     using func_t = void* (*)(void*, uintptr_t);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_ctor);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_ctor);
 
     unk00 = func(nullptr, aUnk);
 }
 
 RED4EXT_INLINE RED4ext::JobHandle::~JobHandle()
 {
     using func_t = void (*)(JobHandle*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_dtor);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_dtor);
 
     func(this);
 }
 
 RED4EXT_INLINE void RED4ext::JobHandle::Join(const JobHandle& aOther)
 {
     using func_t = void (*)(JobHandle*, const JobHandle&);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_Join);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobHandle_Join);
 
     func(this, aOther);
 }
 
 RED4EXT_INLINE RED4ext::JobQueue::JobQueue(const JobGroup& aGroup)
 {
     using func_t = JobQueue* (*)(JobQueue*, const JobGroup&);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_ctor_FromGroup);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_ctor_FromGroup);
 
     func(this, aGroup);
 }
 
 RED4EXT_INLINE RED4ext::JobQueue::JobQueue(JobParamSet aParams, uintptr_t aUnk)
 {
     using func_t = JobQueue* (*)(JobQueue*, uint8_t, uint8_t, uint64_t);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_ctor_FromParams);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_ctor_FromParams);
 
     func(this, aParams.unk00, aParams.unk01, aUnk);
 }
 
 RED4EXT_INLINE RED4ext::JobQueue::~JobQueue()
 {
     using func_t = void (*)(JobQueue*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_dtor);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_dtor);
 
     func(this);
 }
@@ -95,7 +95,7 @@ RED4EXT_INLINE void RED4ext::JobQueue::Wait(JobHandle& aJob)
 RED4EXT_INLINE [[nodiscard]] RED4ext::JobHandle RED4ext::JobQueue::Capture()
 {
     using func_t = JobHandle* (*)(JobQueue*, JobHandle*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_Capture);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_Capture);
 
     JobHandle handle{};
     func(this, &handle);
@@ -106,16 +106,16 @@ RED4EXT_INLINE [[nodiscard]] RED4ext::JobHandle RED4ext::JobQueue::Capture()
 RED4EXT_INLINE void RED4ext::JobQueue::DispatchJob(const JobInstance& aJob)
 {
     using func_t = uint32_t (*)(void*, const JobInstance&, uint8_t, JobHandle, JobHandle);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobDispatcher_DispatchJob);
-    UniversalRelocPtr<void*> dispatcher(Detail::AddressHashes::JobDispatcher);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobDispatcher_DispatchJob);
+    static UniversalRelocPtr<void*> dispatcher(Detail::AddressHashes::JobDispatcher);
 
     func(dispatcher, aJob, params.unk00, unk10, unk18);
 }
 
 RED4EXT_INLINE void RED4ext::JobQueue::SyncWait()
 {
     using func_t = void (*)(JobQueue*);
-    UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_SyncWait);
+    static UniversalRelocFunc<func_t> func(Detail::AddressHashes::JobQueue_SyncWait);
 
     func(this);
 }

include/RED4ext/Memory/Allocators.hpp

@@ -78,7 +78,7 @@ struct Allocator : IAllocator
     virtual AllocationResult Alloc(uint32_t aSize) override
     {
         using alloc_t = void(__fastcall*)(Vault*, AllocationResult*, uint32_t);
-        UniversalRelocFunc<alloc_t> alloc(Detail::AddressHashes::Memory_Vault_Alloc);
+        static UniversalRelocFunc<alloc_t> alloc(Detail::AddressHashes::Memory_Vault_Alloc);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -96,7 +96,7 @@ struct Allocator : IAllocator
     virtual AllocationResult AllocAligned(uint32_t aSize, uint32_t aAlignment) override
     {
         using alloc_t = void (*)(Vault*, AllocationResult*, uint32_t, uint32_t);
-        UniversalRelocFunc<alloc_t> alloc(Detail::AddressHashes::Memory_Vault_AllocAligned);
+        static UniversalRelocFunc<alloc_t> alloc(Detail::AddressHashes::Memory_Vault_AllocAligned);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -114,7 +114,7 @@ struct Allocator : IAllocator
     virtual AllocationResult Realloc(AllocationResult& aAllocation, uint32_t aSize) override
     {
         using realloc_t = void (*)(Vault*, AllocationResult*, AllocationResult&, uint32_t);
-        UniversalRelocFunc<realloc_t> realloc(Detail::AddressHashes::Memory_Vault_Realloc);
+        static UniversalRelocFunc<realloc_t> realloc(Detail::AddressHashes::Memory_Vault_Realloc);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -132,7 +132,7 @@ struct Allocator : IAllocator
     virtual AllocationResult ReallocAligned(AllocationResult& aAllocation, uint32_t aSize, uint32_t aAlignment) override
     {
         using realloc_t = void (*)(Vault*, AllocationResult*, AllocationResult&, uint32_t, uint32_t);
-        UniversalRelocFunc<realloc_t> realloc(Detail::AddressHashes::Memory_Vault_ReallocAligned);
+        static UniversalRelocFunc<realloc_t> realloc(Detail::AddressHashes::Memory_Vault_ReallocAligned);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -150,7 +150,7 @@ struct Allocator : IAllocator
     virtual void Free(AllocationResult& aAllocation) override
     {
         using func_t = void (*)(Vault*, AllocationResult&);
-        UniversalRelocFunc<func_t> func(Detail::AddressHashes::Memory_Vault_Free);
+        static UniversalRelocFunc<func_t> func(Detail::AddressHashes::Memory_Vault_Free);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -160,7 +160,7 @@ struct Allocator : IAllocator
     virtual void sub_28(void* a2) override
     {
         using func_t = void (*)(Vault*, void*);
-        UniversalRelocFunc<func_t> func(Detail::AddressHashes::Memory_Vault_Unk1);
+        static UniversalRelocFunc<func_t> func(Detail::AddressHashes::Memory_Vault_Unk1);
 
         auto pool = T::Get();
         auto storage = pool->storage->GetAllocatorStorage<Vault>();
@@ -184,7 +184,7 @@ struct Allocator : IAllocator
     inline void OOM(uint32_t aSize, uint32_t aAlignment)
     {
         using oom_t = AllocationResult (*)(PoolStorage*, uint32_t, uint32_t);
-        UniversalRelocFunc<oom_t> oom(Detail::AddressHashes::Memory_PoolStorage_OOM);
+        static UniversalRelocFunc<oom_t> oom(Detail::AddressHashes::Memory_PoolStorage_OOM);
 
         auto pool = T::Get();
         oom(pool->storage, aSize, aAlignment);

include/RED4ext/Memory/SharedPtr.hpp

@@ -178,7 +178,7 @@ class SharedPtrBase
         if (refCount)
         {
             // This function also deallocates RefCnt when weakRefs reaches 0.
-            UniversalRelocFunc<void (*)(SharedPtrBase*)> decWeakRefFn(Detail::AddressHashes::Handle_DecWeakRef);
+            static UniversalRelocFunc<void (*)(SharedPtrBase*)> decWeakRefFn(Detail::AddressHashes::Handle_DecWeakRef);
             decWeakRefFn(this);
         }
     }

include/RED4ext/Memory/Vault-inl.hpp

@@ -9,6 +9,6 @@
 
 RED4EXT_INLINE RED4ext::Memory::Vault* RED4ext::Memory::Vault::Get()
 {
-    UniversalRelocPtr<Vault*> ptr(Detail::AddressHashes::Memory_Vault);
+    static UniversalRelocPtr<Vault*> ptr(Detail::AddressHashes::Memory_Vault);
     return reinterpret_cast<Vault*>(ptr.GetAddr());
 }

include/RED4ext/RTTISystem-inl.hpp

@@ -9,7 +9,7 @@
 
 RED4EXT_INLINE RED4ext::CRTTISystem* RED4ext::CRTTISystem::Get()
 {
-    UniversalRelocFunc<CRTTISystem* (*)()> func(Detail::AddressHashes::CRTTISystem_Get);
+    static UniversalRelocFunc<CRTTISystem* (*)()> func(Detail::AddressHashes::CRTTISystem_Get);
     return func();
 }
 
@@ -35,6 +35,6 @@ RED4EXT_INLINE void RED4ext::RTTIRegistrator::Add(CallbackFunc aRegFunc, Callbac
 
 RED4EXT_INLINE const uint32_t RED4ext::RTTIRegistrator::GetNextId()
 {
-    UniversalRelocPtr<volatile uint32_t> ptr(Detail::AddressHashes::CRTTIRegistrator_RTTIAsyncId);
+    static UniversalRelocPtr<volatile uint32_t> ptr(Detail::AddressHashes::CRTTIRegistrator_RTTIAsyncId);
     return InterlockedIncrement(ptr.GetAddr());
 }