Update SpriteLoader, Patch and Injector

ICantReadYourMind · ICantReadYourMind · commit cf20918495ad · 2025-09-23T21:39:16.000+06:00
Fixed uninitialized variables in SpriteLoader, previously there was no way to know if the returned sprite was valid. Patch and Injector now should accept any pointer type, such as member function pointers, to avoid having to use __fastcall or such. Another StaticHook overload was added for convenience.
diff --git a/injector/injector.hpp b/injector/injector.hpp
@@ -28,6 +28,7 @@
 #include <windows.h>
 #include <cstdint>
 #include <cstdio>
+#include <type_traits>
 #include "gvm/gvm.hpp"
 #include "..\shared\DynAddress.h"
 /*
@@ -61,7 +62,24 @@
 
 namespace injector
 {
+/*
+*   valid_pointer_type
+*       Concept to check if T is either a pointer or an integer that fits in a pointer
+*/
+    template <class T>
+    concept valid_pointer_type = std::is_scalar_v<T> && sizeof(T) <= sizeof(uintptr_t) && !std::is_floating_point_v<T>;
 
+/*
+*   to_void_pointer
+*       Function to convert a valid_pointer_type to a void*
+*/
+    template <valid_pointer_type T>
+    inline void* to_void_pointer(T x)
+    {
+		void* p = nullptr;
+		std::memcpy(&p, std::addressof(x), sizeof(T));
+        return p;
+	}
 
 /*
  *  auto_pointer 
@@ -79,8 +97,9 @@ union auto_pointer
     public:
         auto_pointer() : p(0)                          {}
         auto_pointer(const auto_pointer& x) : p(x.p)  {}
-        explicit auto_pointer(void* x)    : p(x)       {}
-        explicit auto_pointer(uint32_t x) : a(x)       {}
+
+        template<valid_pointer_type T>
+        explicit auto_pointer(T x) : p(to_void_pointer(x))       {}
 
         bool is_null() const { return this->p != nullptr; }
 
@@ -117,13 +136,10 @@ union basic_memory_pointer
     public:
         basic_memory_pointer()                      : p(nullptr)    {}
         basic_memory_pointer(std::nullptr_t)        : p(nullptr)    {}
-        basic_memory_pointer(uintptr_t x)           : a(x)          {}
+        template<valid_pointer_type T>
+        basic_memory_pointer(T x)                   : p(to_void_pointer(x))          {}
         basic_memory_pointer(const auto_pointer& x) : p(x.p)        {}
         basic_memory_pointer(const basic_memory_pointer& rhs) : p(rhs.p)  {}
-
-        template<class T>
-        basic_memory_pointer(T* x) : p((void*)x) {}
-
         
 
         
@@ -136,8 +152,9 @@ union basic_memory_pointer
         // Gets the raw pointer, without translation (casted to T*)
         template<class T> T* get_raw() const    { return auto_pointer(p); }
         
-        // This type can get assigned from void* and uintptr_t
-        basic_memory_pointer& operator=(void* x)		{ return p = x, *this; }
+        // This type can get assigned from any pointer and uintptr_t
+        template<valid_pointer_type T>
+        basic_memory_pointer& operator=(T x) { return p = to_void_pointer(x), *this; }
         basic_memory_pointer& operator=(uintptr_t x)	{ return a = x, *this; }
         
         /* Arithmetic */
@@ -222,13 +239,10 @@ union memory_pointer_tr
             : p(rhs.p)
         {}  // Constructs from my own type, copy constructor
         
-        memory_pointer_tr(uintptr_t x)
-            : p(memory_pointer(x).get())
-        {}  // Constructs from a integer, translating the address
-      
-        memory_pointer_tr(void* x)
-            : p(memory_pointer(x).get())
-        {}  // Constructs from a void pointer, translating the address
+        template<valid_pointer_type T>
+        memory_pointer_tr(T x)
+            : p(memory_pointer(to_void_pointer(x)).get())
+        {}  // Constructs from any pointer or integer, translating the address
         
         // Just to be method-compatible with basic_memory_pointer ...
         auto_pointer         get()      { return auto_pointer(p);     }
diff --git a/shared/Patch.cpp b/shared/Patch.cpp
@@ -41,11 +41,11 @@ void plugin::patch::Nop(uintptr_t address, size_t size, bool vp) {
     injector::MakeNOP(GetGlobalAddress(address), size, vp);
 }
 
-void plugin::patch::RedirectCall(uintptr_t address, void *func, bool vp) {
+void plugin::patch::RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp) {
     injector::MakeCALL(GetGlobalAddress(address), func, vp);
 }
 
-void plugin::patch::RedirectJump(uintptr_t address, void *func, bool vp) {
+void plugin::patch::RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp) {
     injector::MakeJMP(GetGlobalAddress(address), func, vp);
 }
 
@@ -77,7 +77,7 @@ void plugin::patch::SetFloat(uintptr_t address, float value, bool vp) {
     injector::WriteMemory(GetGlobalAddress(address), value, vp);
 }
 
-void plugin::patch::SetPointer(uintptr_t address, void *value, bool vp) {
+void plugin::patch::SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp) {
     injector::WriteMemory(GetGlobalAddress(address), value, vp);
 }
 
@@ -130,7 +130,7 @@ void plugin::patch::GetRaw(uintptr_t address,void* ret, size_t size, bool vp) {
     injector::ReadMemoryRaw(GetGlobalAddress(address), ret, size, vp);
 }
 
-void plugin::patch::RedirectShortJump(uintptr_t address, void* dest, bool vp) {
+void plugin::patch::RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest, bool vp) {
 
     uintptr_t GlobalAddress = GetGlobalAddress(address);
     injector::WriteMemory<uint8_t>(GlobalAddress, 0xEB, vp);
diff --git a/shared/Patch.h b/shared/Patch.h
@@ -23,16 +23,16 @@ class patch {
 public:
     static void NopRestore(uintptr_t address, bool vp = true);
     static void Nop(uintptr_t address, size_t size, bool vp = true);
-    static void RedirectCall(uintptr_t address, void *func, bool vp = true);
-    static void RedirectJump(uintptr_t address, void *func, bool vp = true);
+    static void RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp = true);
+    static void RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp = true);
     static void SetChar(uintptr_t address, char value, bool vp = true);
     static void SetUChar(uintptr_t address, unsigned char value, bool vp = true);
     static void SetShort(uintptr_t address, short value, bool vp = true);
     static void SetUShort(uintptr_t address, unsigned short value, bool vp = true);
     static void SetInt(uintptr_t address, uintptr_t value, bool vp = true);
     static void SetUInt(uintptr_t address, uintptr_t value, bool vp = true);
     static void SetFloat(uintptr_t address, float value, bool vp = true);
-    static void SetPointer(uintptr_t address, void *value, bool vp = true);
+    static void SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp = true);
     static char GetChar(uintptr_t address, bool vp = true);
     static unsigned char GetUChar(uintptr_t address, bool vp = true);
     static short GetShort(uintptr_t address, bool vp = true);
@@ -43,23 +43,23 @@ class patch {
     static void *GetPointer(uintptr_t address, bool vp = true);
     static void SetRaw(uintptr_t address, void* value, size_t size, bool vp = true);
     static void GetRaw(uintptr_t address, void* ret, size_t size, bool vp = true);
-    static void RedirectShortJump(uintptr_t address, void* dest = nullptr, bool vp = true);
+    static void RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest = nullptr, bool vp = true);
     static void PutRetn(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
     static void PutRetn0(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
     static void PutRetn1(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
 
     template <typename T>
-    static void Set(uintptr_t address, T value, bool vp = true) {
+    static inline void Set(uintptr_t address, T value, bool vp = true) {
         injector::WriteMemory(GetGlobalAddress(address), value, vp);
     }
 
     template <typename T>
-    static T Get(uintptr_t address, bool vp = true) {
+    static inline T Get(uintptr_t address, bool vp = true) {
         return injector::ReadMemory<T>(GetGlobalAddress(address), vp);
     }
 
     template <typename T>
-    static T TranslateCallOffset(uintptr_t address) {
+    static inline T TranslateCallOffset(uintptr_t address) {
         if (GetUChar(address) == 0xE8) {
             auto offset = GetInt(address + 1);
             offset += (GetGlobalAddress(address) + 5);
@@ -69,7 +69,7 @@ class patch {
     }
 
     template <typename T>
-    static T TranslateJumpOffset(uintptr_t address) {
+    static inline T TranslateJumpOffset(uintptr_t address) {
         if (GetUChar(address) == 0xE9) {
             auto offset = GetInt(address + 1);
             offset += (GetGlobalAddress(address) + 5);
@@ -81,52 +81,52 @@ class patch {
     static void ReplaceFunction(uintptr_t address, void *func, bool vp = true);
     static void ReplaceFunctionCall(uintptr_t address, void *func, bool vp = true);
 
-    static void SetPointer(std::vector<uintptr_t> const& addresses, void* value, bool vp = true) {
+    static inline void SetPointer(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw value, bool vp = true) {
         for (auto& address : addresses) {
             SetPointer(address, value, vp);
         }
     }
 
     template <typename T>
-    static void Set(std::vector<uintptr_t> const& addresses, T value, bool vp = true) {
+    static inline void Set(std::vector<uintptr_t> const& addresses, T value, bool vp = true) {
         for (auto& address : addresses) {
             Set(address, value, vp);
         }
     }
 
-    static void SetInt(std::vector<uintptr_t> const& addresses, uintptr_t value, bool vp = true) {
+    static inline void SetInt(std::vector<uintptr_t> const& addresses, uintptr_t value, bool vp = true) {
         for (auto& address : addresses) {
             SetInt(address, value, vp);
         }
     }
 
-    static void SetFloat(std::vector<uintptr_t> const& addresses, float value, bool vp = true) {
+    static inline void SetFloat(std::vector<uintptr_t> const& addresses, float value, bool vp = true) {
         for (auto& address : addresses) {
             SetFloat(address, value, vp);
         }
     }
 
-    static void RedirectJump(std::vector<uintptr_t> const& addresses, void* func, bool vp = true) {
+    static inline void RedirectJump(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw func, bool vp = true) {
         for (auto& address : addresses) {
             RedirectJump(address, func, vp);
         }
     }
 
-    static void RedirectCall(std::vector<uintptr_t> const& addresses, void* func, bool vp = true) {
+    static inline void RedirectCall(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw func, bool vp = true) {
         for (auto& address : addresses) {
             RedirectCall(address, func, vp);
         }
     }
 
-    static void Nop(std::vector<uintptr_t> const& addresses, size_t size, bool vp = true) {
+    static inline void Nop(std::vector<uintptr_t> const& addresses, size_t size, bool vp = true) {
         for (auto& address : addresses) {
             Nop(address, size, vp);
         }
     }
 
     using RegPack = injector::reg_pack;
 
-    static void StaticHook(uintptr_t start, uintptr_t end, void (*func)(RegPack&)) {
+    static inline void StaticHook(uintptr_t start, uintptr_t end, void (*func)(RegPack&)) {
         struct staticHook {
             void (*func)(RegPack&);
 
@@ -143,8 +143,12 @@ class patch {
         injector::MakeInline(start, end, *ptr);
     }
 
+    static inline void StaticHook(uintptr_t address, void (*func)(RegPack&)) {
+        StaticHook(address, address + 5, func);
+	}
+
     template <typename T>
-    static void StaticHook(uintptr_t start, uintptr_t end) {
+    static inline void StaticHook(uintptr_t start, uintptr_t end) {
         injector::MakeInline<T>(start, end);
     }
 };
diff --git a/shared/SpriteLoader.cpp b/shared/SpriteLoader.cpp
@@ -204,7 +204,7 @@ namespace plugin {
     }
 
     CSprite2d SpriteLoader::GetSprite(std::string const& name) {
-        CSprite2d sprite;
+        CSprite2d sprite = {};
         auto s = spritesMap.find(name);
         if (s != spritesMap.end())
             sprite.m_pTexture = s->second;
@@ -213,7 +213,7 @@ namespace plugin {
     }
 
     CSprite2d SpriteLoader::GetSprite(uint32_t id) {
-        CSprite2d sprite;
+        CSprite2d sprite = {};
 
         auto s = spritesMapIndex.find(id);
         if (s != spritesMapIndex.end())
@@ -233,7 +233,7 @@ namespace plugin {
         mipMap = on;
     }
 
-    void SpriteLoader::SetExtension(std::string ext) {
+    void SpriteLoader::SetExtension(std::string const& ext) {
         extension = ext;
     }
 
diff --git a/shared/SpriteLoader.h b/shared/SpriteLoader.h
@@ -64,7 +64,7 @@ namespace plugin {
         CSprite2d GetSprite(uint32_t id);
         texClass* GetTex(std::string const& name);
         void SetMipMapOn(bool on);
-        void SetExtension(std::string ext);
+        void SetExtension(std::string const& ext);
         uint32_t GetMemoryUsed();
     };
 }

Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,11 @@ void plugin::patch::Nop(uintptr_t address, size_t size, bool vp) {`
`41`	`41`	`injector::MakeNOP(GetGlobalAddress(address), size, vp);`
`42`	`42`	`}`
`43`	`43`
`44`		`-void plugin::patch::RedirectCall(uintptr_t address, void *func, bool vp) {`
	`44`	`+void plugin::patch::RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp) {`
`45`	`45`	`injector::MakeCALL(GetGlobalAddress(address), func, vp);`
`46`	`46`	`}`
`47`	`47`
`48`		`-void plugin::patch::RedirectJump(uintptr_t address, void *func, bool vp) {`
	`48`	`+void plugin::patch::RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp) {`
`49`	`49`	`injector::MakeJMP(GetGlobalAddress(address), func, vp);`
`50`	`50`	`}`
`51`	`51`
`@@ -77,7 +77,7 @@ void plugin::patch::SetFloat(uintptr_t address, float value, bool vp) {`
`77`	`77`	`injector::WriteMemory(GetGlobalAddress(address), value, vp);`
`78`	`78`	`}`
`79`	`79`
`80`		`-void plugin::patch::SetPointer(uintptr_t address, void *value, bool vp) {`
	`80`	`+void plugin::patch::SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp) {`
`81`	`81`	`injector::WriteMemory(GetGlobalAddress(address), value, vp);`
`82`	`82`	`}`
`83`	`83`
`@@ -130,7 +130,7 @@ void plugin::patch::GetRaw(uintptr_t address,void* ret, size_t size, bool vp) {`
`130`	`130`	`injector::ReadMemoryRaw(GetGlobalAddress(address), ret, size, vp);`
`131`	`131`	`}`
`132`	`132`
`133`		`-void plugin::patch::RedirectShortJump(uintptr_t address, void* dest, bool vp) {`
	`133`	`+void plugin::patch::RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest, bool vp) {`
`134`	`134`
`135`	`135`	`uintptr_t GlobalAddress = GetGlobalAddress(address);`
`136`	`136`	`injector::WriteMemory<uint8_t>(GlobalAddress, 0xEB, vp);`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ namespace plugin {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`CSprite2d SpriteLoader::GetSprite(std::string const& name) {`
`207`		`- CSprite2d sprite;`
	`207`	`+ CSprite2d sprite = {};`
`208`	`208`	`auto s = spritesMap.find(name);`
`209`	`209`	`if (s != spritesMap.end())`
`210`	`210`	`sprite.m_pTexture = s->second;`
`@@ -213,7 +213,7 @@ namespace plugin {`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`CSprite2d SpriteLoader::GetSprite(uint32_t id) {`
`216`		`- CSprite2d sprite;`
	`216`	`+ CSprite2d sprite = {};`
`217`	`217`
`218`	`218`	`auto s = spritesMapIndex.find(id);`
`219`	`219`	`if (s != spritesMapIndex.end())`
`@@ -233,7 +233,7 @@ namespace plugin {`
`233`	`233`	`mipMap = on;`
`234`	`234`	`}`
`235`	`235`
`236`		`- void SpriteLoader::SetExtension(std::string ext) {`
	`236`	`+ void SpriteLoader::SetExtension(std::string const& ext) {`
`237`	`237`	`extension = ext;`
`238`	`238`	`}`
`239`	`239`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ namespace plugin {`
`64`	`64`	`CSprite2d GetSprite(uint32_t id);`
`65`	`65`	`texClass* GetTex(std::string const& name);`
`66`	`66`	`void SetMipMapOn(bool on);`
`67`		`- void SetExtension(std::string ext);`
	`67`	`+ void SetExtension(std::string const& ext);`
`68`	`68`	`uint32_t GetMemoryUsed();`
`69`	`69`	`};`
`70`	`70`	`}`