ReshadePluginsCore/Memory/Memory.hpp

#pragma once

#include <spdlog/spdlog.h>

#define AUTO_ASSEMBLE_TRAMPOLINE(ADDRESS, TRAMPOLINE_LENGTH, INSTRUCTIONS) \
do { \
auto allocMemory = Memory::AllocateNearbyMemory(ADDRESS, sizeof INSTRUCTIONS + 14); \
Memory::CreateTrampoline(ADDRESS, allocMemory, TRAMPOLINE_LENGTH); \
Memory::WriteInstructions(allocMemory, INSTRUCTIONS, sizeof INSTRUCTIONS, ADDRESS + TRAMPOLINE_LENGTH); \
} while (false)


class Memory
{
    public:

		/**
		 * Get offset from opcode.
		 *
		 * @param opcode : The address where the offset begins.
		 */
		static uint8_t* GetOffsetFromOpcode(uint8_t* opcode);

		/**
		 * Converts flkoat 32 bits into a char*.
		 *
		 * @param value : The value to encode.
		 */
		static const char* Float32ToHexBytes(float value);

		/**
		 * Read x bytes in memory.
		 *
		 * @param address : The address to read.
		 * @param size : The size in bytes to read
		 * @std::vector<std::uint8_t> : The bytes read.
		 */
		static std::vector<std::uint8_t> ReadBytes(const void* addr, std::size_t size);

		/**
		 * Patch x bytes in memory.
		 *
		 * @param address : The address to patch.
		 * @param bytes : The bytes to patch
		 * @param len : The number of bytes to be patched
		 */
		static void PatchBytes(void* address, const char* bytes, size_t len);

		/**
		 * Restore x bytes in memory.
		 *
		 * @param address : The address to patch.
		 */
		static void RestoreBytes(void* address);

		/**
		 * Achieve an AOB scan in memory.
		 *
		 * @param module_name : The executable to scan.
		 * @param signature : The signature to search for (eg : 7F ?? F3 0F ?? ?? ?? F2)
		 * @param protect_flags : Page protection (PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_READWRITE | PAGE_EXECUTE_WRITECOPY)
		 * @param log : If any log is to be used
		 * @return uint_8* : Pointer to address where AOB is found.
		 */
        static uint8_t* AOBScan(const std::string& module_name, const std::string& signature, DWORD protect_flags, std::shared_ptr<spdlog::logger> log = nullptr);

		static std::string ByteToHexEscaped(const BYTE byte);

		/**
		 * Set or clear VEH hardware breakpoint.
		 *
		 * @param targetAddress : The memory target to set a VEH breakpoint.
		 * @param vehHandle : The VEH handle (nullptr when to set breakpoint or a handle when to unset
		 * @param enable : Set or unset the VEH debugger
		 * @param pVEH : The function where to detour (set to nullptr to unset)
		 * @param hwIndex : The hawdware breakpoint to set (0 - 4)
		 * @return hwIndex : The VEH breakpoint handle
		 */
		static PVOID SetupOrClearHardwareBreakPointForAllThreads(uintptr_t targetAddress, PVOID vehHandle, bool enable, PVECTORED_EXCEPTION_HANDLER pVEH = nullptr, int hwIndex = 0);
	private:
		static bool WaitForModule(const std::string& module_name, int timeoutMs, int intervalMs);
		struct PatchInfo {
			void* address;
			std::vector<BYTE> originalBytes;
			bool hasTrampoline = false;
			void* trampolineDestination = nullptr;
		};

		static std::unordered_map<void*, PatchInfo> patches;
};