Add GetVirtualMethodIndex method

& update `CVirtualTable` class

Author: Wend4r

include/dynlibutils/virtual.hpp

@@ -7,28 +7,70 @@
 
 #pragma once
 
+#include "memaddr.hpp"
+
 #include <cstddef>
+#include <cstdint>
+#include <bit>
+#include <type_traits>
+
+#define DYNLIB_INVALID_VMETHOD_INDEX -1
 
 namespace DynLibUtils {
 
-class CVirtualTable
+template<auto METHOD, class T>
+inline std::ptrdiff_t GetVirtualMethodIndex(T *pClass) noexcept
+{
+	static_assert(std::is_member_function_pointer_v<decltype(METHOD)>, "Templated method must be a pointer-to-member-function");
+
+#if defined(_MSC_VER)
+	// --- MSVC ABI: runtime scan vtable (no constexpr!) ---
+	struct MSVCPMF { void* ptr; std::ptrdiff_t adj; };
+	union { decltype(METHOD) m; MSVCPMF pmf; } u{ METHOD };
+	void* target = u.pmf.ptr;
+
+	void** vtbl = *reinterpret_cast<void***>(pClass);
+
+	constexpr std::size_t header = 2; // [RTTI][offset-to-top]
+
+	for (std::size_t n = header; ; ++n)
+		if (vtbl[n] == target)
+			return n - header;
+
+#elif defined(__GNUG__) || defined(__clang__)
+	// --- Itanium C++ ABI: PMF.ptr = 1 + offset_in_bytes for virtual ones ---
+	struct ItaniumPMF { void* ptr; std::ptrdiff_t adj; };
+	union { decltype(METHOD) m; ItaniumPMF pmf; } u{ METHOD };
+
+	constexpr auto raw = reinterpret_cast<std::uintptr_t>(u.pmf.ptr);
+
+	static_assert((raw & 1u) != 0, "Not a virtual member function");
+
+	return (raw - 1u) / sizeof(void*);
+#else
+	static_assert(false, "Unsupported compiler");
+#endif
+
+	return DYNLIB_INVALID_VMETHOD_INDEX;
+}
+
+class CVirtualTable : public CMemoryView<void *>
 {
 public: // Types.
+	using CBase = CMemoryView<void *>;
 	using CThis = CVirtualTable;
 
 public: // Constructors.
-	CVirtualTable() : m_pVTFs(nullptr) {}
-	template<class T> CVirtualTable(T *pClass) : m_pVTFs(*reinterpret_cast<void ***>(pClass)) {}
+	CVirtualTable() : CBase(nullptr) {}
+	template<class T> CVirtualTable(T *pClass) : CBase(*reinterpret_cast<void **>(pClass)) {}
 
 public: // Getters.
-	template<typename R> R &GetMethod(std::ptrdiff_t nIndex) { return reinterpret_cast<R &>(m_pVTFs[nIndex]); }
-	template<typename R> R GetMethod(std::ptrdiff_t nIndex) const { return reinterpret_cast<R>(m_pVTFs[nIndex]); }
+	template<typename R> R &GetMethod(std::ptrdiff_t nIndex) { return CBase::Offset(nIndex).RCast<R &>(); }
+	template<typename R> R GetMethod(std::ptrdiff_t nIndex) const { return CBase::Offset(nIndex).RCast<R>(); }
 
 public: // Callers.
 	template<typename R, typename... Args> R CallMethod(std::ptrdiff_t nIndex, Args... args) { return GetMethod<R (*)(void *, Args...)>(nIndex)(this, args...); }
 	template<typename R, typename... Args> R CallMethod(std::ptrdiff_t nIndex, Args... args) const { return const_cast<CThis *>(this)->CallMethod(nIndex, args...); }
-
-	void **m_pVTFs;
 }; // class CVirtualTable
 
 class VirtualTable final : public CVirtualTable

include/dynlibutils/vthook.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "memaddr.hpp"
+#include "virtual.hpp"
 
 #if _WIN32
 #	define WIN32_LEAN_AND_MEAN
@@ -71,33 +72,47 @@ class VTHook
 	VTHook() = default;
 	~VTHook() { Unhook(); }
 
+	void Clear()
+	{
+		m_vmpFn = nullptr;
+		m_pOriginalFn = nullptr;
+	}
+
 	bool IsHooked() const { return m_pOriginalFn.IsValid(); }
+	T Call(C* pThis, Args... args) { return m_pOriginalFn.RCast<T(*)(C*, Args...)>()(pThis, args...); }
 
-	void Hook(CMemory pVTable, int index, T(*pFn)(C*, Args...))
+	void Hook(CVirtualTable pVTable, std::ptrdiff_t nIndex, T(*pFn)(C*, Args...))
 	{
 		assert(!IsHooked());
 
-		m_vmpFn = pVTable.Offset(index * sizeof(void*));
+		m_vmpFn = pVTable.Offset(nIndex);
 		m_pOriginalFn = m_vmpFn.Deref();
 
-		MemUnprotector unprotector(m_vmpFn);
-
-		*m_vmpFn.RCast<T(**)(C*, Args...)>() = pFn;
+		HookImpl(pFn);
 	}
 
 	void Unhook()
 	{
 		assert(IsHooked());
 
-		MemUnprotector unprotector(m_vmpFn);
+		UnhookImpl();
+		Clear();
+	}
 
-		*m_vmpFn.RCast<void**>() = m_pOriginalFn;
+protected:
+	void HookImpl(T(*pfnTarget)(C*, Args...))
+	{
+		MemUnprotector unprotector(m_vmpFn);
 
-		m_vmpFn = nullptr;
-		m_pOriginalFn = nullptr;
+		*m_vmpFn.RCast<T(**)(C*, Args...)>() = pfnTarget;
 	}
 
-	T Call(C* pThis, Args... args) { return m_pOriginalFn.RCast<T(*)(C*, Args...)>()(pThis, args...); }
+	void UnhookImpl()
+	{
+		MemUnprotector unprotector(m_vmpFn);
+
+		*m_vmpFn.RCast<void **>() = m_pOriginalFn;
+	}
 
 private:
 	CMemory m_vmpFn;