#ifndef UNITYRESOLVE_HPP

#define UNITYRESOLVE_HPP

// ============================== 自动检测当前环境 ==============================

#if defined(_WIN32) || defined(_WIN64)

#define WINDOWS_MODE 1

#else

#define WINDOWS_MODE 0

#endif

#if defined(__ANDROID__)

#define ANDROID_MODE 1

#else

#define ANDROID_MODE 0

#endif

#if defined(TARGET_OS_IOS)

#define IOS_MODE 1

#else

#define IOS_MODE 0

#endif

#if defined(__linux__) && !defined(__ANDROID__)

#define LINUX_MODE 1

#else

#define LINUX_MODE 0

#endif

#if defined(__harmony__) && !defined(_HARMONYOS)

#define HARMONYOS_MODE 1

#else

#define HARMONYOS_MODE 0

#endif

// ============================== 强制设置当前执行环境 ==============================

// #define WINDOWS_MODE 0

// #define ANDROID_MODE 1 // 设置运行环境

// #define LINUX_MODE 0

// #define IOS_MODE 0

// #define HARMONYOS_MODE 0

// ============================== 导入对应环境依赖 ==============================

#if WINDOWS_MODE || LINUX_MODE || IOS_MODE

#include <format>

#include <ranges>

#include <regex>

#endif

#if IOS_MODE

#include <algorithm>

#endif

#include <codecvt>

#include <fstream>

#include <iostream>

#include <mutex>

#include <string>

#include <unordered_map>

#include <vector>

#include <functional>

#include <numbers>

#ifdef USE_GLM

#include <glm/glm.hpp>

#endif

#if WINDOWS_MODE

#include <windows.h>

#undef GetObject

#endif

#if WINDOWS_MODE

#ifdef _WIN64

#define UNITY_CALLING_CONVENTION __fastcall

#elif _WIN32

#define UNITY_CALLING_CONVENTION __cdecl

#endif

#elif ANDROID_MODE || LINUX_MODE || IOS_MODE || HARMONYOS_MODE

#include <locale>

#include <dlfcn.h>

#define UNITY_CALLING_CONVENTION

#endif

class UnityResolve final {

public:

struct Assembly;

struct Type;

struct Class;

struct Field;

struct Method;

class UnityType;

enum class Mode : char {

Il2Cpp,

Mono,

};

struct Assembly final {

void* address;

std::string name;

std::string file;

std::vector<Class*> classes;

[[nodiscard]] auto Get(const std::string& strClass, const std::string& strNamespace = "*", const std::string& strParent = "*") const -> Class* {

for (const auto pClass : classes) if (strClass == pClass->name && (strNamespace == "*" || pClass->namespaze == strNamespace) && (strParent == "*" || pClass->parent == strParent)) return pClass;

return nullptr;

}

};

struct Type final {

void* address;

std::string name;

int size;

// UnityType::CsType*

[[nodiscard]] auto GetCSType() const -> void* {

if (mode_ == Mode::Il2Cpp) return Invoke<void*>("il2cpp_type_get_object", address);

return Invoke<void*>("mono_type_get_object", pDomain, address);

}

};

struct Class final {

void* address;

std::string name;

std::string parent;

std::string namespaze;

std::vector<Field*> fields;

std::vector<Method*> methods;

void* objType;

template <typename RType>

auto Get(const std::string& name, const std::vector<std::string>& args = {}) -> RType* {

if constexpr (std::is_same_v<RType, Field>) for (auto pField : fields) if (pField->name == name) return static_cast<RType*>(pField);

if constexpr (std::is_same_v<RType, std::int32_t>) for (const auto pField : fields) if (pField->name == name) return reinterpret_cast<RType*>(pField->offset);

if constexpr (std::is_same_v<RType, Method>) {

for (auto pMethod : methods) {

if (pMethod->name == name) {

if (pMethod->args.empty() && args.empty()) return static_cast<RType*>(pMethod);

if (pMethod->args.size() == args.size()) {

size_t index{ 0 };

for (size_t i{ 0 }; const auto & typeName : args) if (typeName == "*" || typeName.empty() ? true : pMethod->args[i++]->pType->name == typeName) index++;

if (index == pMethod->args.size()) return static_cast<RType*>(pMethod);

}

}

}

for (auto pMethod : methods) if (pMethod->name == name) return static_cast<RType*>(pMethod);

}

return nullptr;

}

template <typename RType>

auto GetValue(void* obj, const std::string& name) -> RType { return *reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + Get<Field>(name)->offset); }

template <typename RType>

auto GetValue(void* obj, unsigned int offset) -> RType { return *reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + offset); }

template <typename RType>

auto SetValue(void* obj, const std::string& name, RType value) -> void { *reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + Get<Field>(name)->offset) = value; }

template <typename RType>

auto SetValue(void* obj, unsigned int offset, RType value) -> RType { *reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + offset) = value; }

// UnityType::CsType*

[[nodiscard]] auto GetType() -> void* {

if (objType) return objType;

if (mode_ == Mode::Il2Cpp) {

const auto pUType = Invoke<void*, void*>("il2cpp_class_get_type", address);

objType = Invoke<void*>("il2cpp_type_get_object", pUType);

return objType;

}

const auto pUType = Invoke<void*, void*>("mono_class_get_type", address);

objType = Invoke<void*>("mono_type_get_object", pDomain, pUType);

return objType;

}

/**

* \brief 获取类所有实例

* \tparam T 返回数组类型

* \param type 类

* \return 返回实例指针数组

*/

template <typename T>

auto FindObjectsByType() -> std::vector<T> {

static Method* pMethod;

if (!pMethod) pMethod = UnityResolve::Get("UnityEngine.CoreModule.dll")->Get("Object")->Get<Method>("FindObjectsOfType", { "System.Type" });

if (!objType) objType = this->GetType();

if (pMethod && objType) if (auto array = pMethod->Invoke<UnityType::Array<T>*>(objType)) return array->ToVector();

return std::vector<T>(0);

}

template <typename T>

auto New() -> T* {

if (mode_ == Mode::Il2Cpp) return Invoke<T*, void*>("il2cpp_object_new", address);

return Invoke<T*, void*, void*>("mono_object_new", pDomain, address);

}

};

struct Field final {

void* address;

std::string name;

Type* type;

Class* klass;

std::int32_t offset; // If offset is -1, then it's thread static

bool static_field;

void* vTable;

template <typename T>

auto SetStaticValue(T* value) const -> void {

if (!static_field) return;

if (mode_ == Mode::Il2Cpp) return Invoke<void, void*, T*>("il2cpp_field_static_set_value", address, value);

else

{

void* VTable = Invoke<void*>("mono_class_vtable", pDomain, klass->address);

return Invoke<void, void*, void*, T*>("mono_field_static_set_value", VTable, address, value);

}

}

template <typename T>

auto GetStaticValue(T* value) const -> void {

if (!static_field) return;

if (mode_ == Mode::Il2Cpp) return Invoke<void, void*, T*>("il2cpp_field_static_get_value", address, value);

else

{

void* VTable = Invoke<void*>("mono_class_vtable", pDomain, klass->address);

return Invoke<void, void*, void*, T*>("mono_field_static_get_value", VTable, address, value);

}

}

template <typename T, typename C>

struct Variable {

private:

std::int32_t offset{ 0 };

public:

void Init(const Field* field) {

offset = field->offset;

}

T Get(C* obj) {

return *reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(obj) + offset);

}

void Set(C* obj, T value) {

*reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(obj) + offset) = value;

}

T& operator[](C* obj) {

return *reinterpret_cast<T*>(offset + reinterpret_cast<std::uintptr_t>(obj));

}

};

};

template <typename Return, typename... Args>

using MethodPointer = Return(UNITY_CALLING_CONVENTION*)(Args...);

struct Method final {

void* address;

std::string name;

Class* klass;

Type* return_type;

std::int32_t flags;

bool static_function;

void* function;

struct Arg {

std::string name;

Type* pType;

};

std::vector<Arg*> args;

public:

template <typename Return, typename... Args>

auto Invoke(Args... args) -> Return {

Compile();

if (function) return reinterpret_cast<Return(UNITY_CALLING_CONVENTION*)(Args...)>(function)(args...);

return Return();

}

auto Compile() -> void {

if (address && !function && mode_ == Mode::Mono) function = UnityResolve::Invoke<void*>("mono_compile_method", address);

}

template <typename Return, typename Obj = void, typename... Args>

auto RuntimeInvoke(Obj* obj, Args... args) -> Return {

void* argArray[sizeof...(Args)] = { static_cast<void*>(&args)... };

if (mode_ == Mode::Il2Cpp) {

if constexpr (std::is_void_v<Return>) {

UnityResolve::Invoke<void*>("il2cpp_runtime_invoke", address, obj, sizeof...(Args) ? argArray : nullptr, nullptr);

return;

}

else return Unbox<Return>(Invoke<void*>("il2cpp_runtime_invoke", address, obj, sizeof...(Args) ? argArray : nullptr, nullptr));

}

if constexpr (std::is_void_v<Return>) {

UnityResolve::Invoke<void*>("mono_runtime_invoke", address, obj, sizeof...(Args) ? argArray : nullptr, nullptr);

return;

}

else return Unbox<Return>(Invoke<void*>("mono_runtime_invoke", address, obj, sizeof...(Args) ? argArray : nullptr, nullptr));

}

template <typename Return, typename... Args>

auto Cast() -> MethodPointer<Return, Args...> {

Compile();

if (function) return reinterpret_cast<MethodPointer<Return, Args...>>(function);

return nullptr;

}

template <typename Return, typename... Args>

auto Cast(MethodPointer<Return, Args...>& ptr) -> MethodPointer<Return, Args...> {

Compile();

if (function) {

ptr = reinterpret_cast<MethodPointer<Return, Args...>>(function);

return reinterpret_cast<MethodPointer<Return, Args...>>(function);

}

return nullptr;

}

template <typename Return, typename... Args>

auto Cast(std::function<Return(Args...)>& ptr) -> std::function<Return(Args...)> {

Compile();

if (function) {

ptr = reinterpret_cast<MethodPointer<Return, Args...>>(function);

return reinterpret_cast<MethodPointer<Return, Args...>>(function);

}

return nullptr;

}

template <typename T>

T Unbox(void* obj) {

if (mode_ == Mode::Il2Cpp) {

return static_cast<T>(Invoke<void*>("mono_object_unbox", obj));

}

else {

return static_cast<T>(Invoke<void*>("il2cpp_object_unbox", obj));

}

}

};

class AssemblyLoad {

public:

AssemblyLoad(const std::string path, std::string namespaze = "", std::string className = "", std::string desc = "") {

if (mode_ == Mode::Mono) {

assembly = Invoke<void*>("mono_domain_assembly_open", pDomain, path.data());

image = Invoke<void*>("mono_assembly_get_image", assembly);

if (namespaze.empty() || className.empty() || desc.empty()) {

return;

}

klass = Invoke<void*>("mono_class_from_name", image, namespaze.data(), className.data());

void* entry_point_method_desc = Invoke<void*>("mono_method_desc_new", desc.data(), true);

method = Invoke<void*>("mono_method_desc_search_in_class", entry_point_method_desc, klass);

Invoke<void>("mono_method_desc_free", entry_point_method_desc);

Invoke<void*>("mono_runtime_invoke", method, nullptr, nullptr, nullptr);

}

}

void* assembly;

void* image;

void* klass;

void* method;

};

static auto ThreadAttach() -> void {

if (mode_ == Mode::Il2Cpp) Invoke<void*>("il2cpp_thread_attach", pDomain);

else {

Invoke<void*>("mono_thread_attach", pDomain);

Invoke<void*>("mono_jit_thread_attach", pDomain);

}

}

static auto ThreadDetach() -> void {

if (mode_ == Mode::Il2Cpp) Invoke<void*>("il2cpp_thread_detach", pDomain);

else {

Invoke<void*>("mono_thread_detach", pDomain);

Invoke<void*>("mono_jit_thread_detach", pDomain);

}

}

static auto Init(void* hmodule, const Mode mode = Mode::Mono) -> void {

mode_ = mode;

hmodule_ = hmodule;

if (mode_ == Mode::Il2Cpp) {

pDomain = Invoke<void*>("il2cpp_domain_get");

Invoke<void*>("il2cpp_thread_attach", pDomain);

ForeachAssembly();

}

else {

pDomain = Invoke<void*>("mono_get_root_domain");

Invoke<void*>("mono_thread_attach", pDomain);

Invoke<void*>("mono_jit_thread_attach", pDomain);

ForeachAssembly();

}

}

#if WINDOWS_MODE || LINUX_MODE || IOS_MODE /*__cplusplus >= 202002L*/

static auto DumpToFile(const std::string path) -> void {

std::ofstream io(path + "dump.cs", std::fstream::out);

if (!io) return;

for (const auto& pAssembly : assembly) {

for (const auto& pClass : pAssembly->classes) {

io << std::format("\tnamespace: {}", pClass->namespaze.empty() ? "" : pClass->namespaze);

io << "\n";

io << std::format("\tAssembly: {}\n", pAssembly->name.empty() ? "" : pAssembly->name);

io << std::format("\tAssemblyFile: {} \n", pAssembly->file.empty() ? "" : pAssembly->file);

io << std::format("\tclass {}{} ", pClass->name, pClass->parent.empty() ? "" : " : " + pClass->parent);

io << "{\n\n";

for (const auto& pField : pClass->fields) io << std::format("\t\t{:+#06X} | {}{} {};\n", pField->offset, pField->static_field ? "static " : "", pField->type->name, pField->name);

io << "\n";

for (const auto& pMethod : pClass->methods) {

io << std::format("\t\t[Flags: {:032b}] [ParamsCount: {:04d}] |RVA: {:+#010X}|\n", pMethod->flags, pMethod->args.size(), reinterpret_cast<std::uint64_t>(pMethod->function) - reinterpret_cast<std::uint64_t>(hmodule_));

io << std::format("\t\t{}{} {}(", pMethod->static_function ? "static " : "", pMethod->return_type->name, pMethod->name);

std::string params{};

for (const auto& pArg : pMethod->args) params += std::format("{} {}, ", pArg->pType->name, pArg->name);

if (!params.empty()) {

params.pop_back();

params.pop_back();

}

io << (params.empty() ? "" : params) << ");\n\n";

}

io << "\t}\n\n";

}

}

io << '\n';

io.close();

std::ofstream io2(path + "struct.hpp", std::fstream::out);

if (!io2) return;

for (const auto& pAssembly : assembly) {

for (const auto& pClass : pAssembly->classes) {

io2 << std::format("\tnamespace: {}", pClass->namespaze.empty() ? "" : pClass->namespaze);

io2 << "\n";

io2 << std::format("\tAssembly: {}\n", pAssembly->name.empty() ? "" : pAssembly->name);

io2 << std::format("\tAssemblyFile: {} \n", pAssembly->file.empty() ? "" : pAssembly->file);

io2 << std::format("\tstruct {}{} ", pClass->name, pClass->parent.empty() ? "" : " : " + pClass->parent);

io2 << "{\n\n";

for (size_t i = 0; i < pClass->fields.size(); i++) {

if (pClass->fields[i]->static_field) continue;

auto field = pClass->fields[i];

next: if ((i + 1) >= pClass->fields.size()) {

io2 << std::format("\t\tchar {}[0x{:06X}];\n", field->name, 0x4);

continue;

}

if (pClass->fields[i + 1]->static_field) {

i++;

goto next;

}

std::string name = field->name;

std::ranges::replace(name, '<', '_');

std::ranges::replace(name, '>', '_');

if (field->type->name == "System.Int64") {

io2 << std::format("\t\tstd::int64_t {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 8) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 8);

continue;

}

if (field->type->name == "System.UInt64") {

io2 << std::format("\t\tstd::uint64_t {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 8) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 8);

continue;

}

if (field->type->name == "System.Int32") {

io2 << std::format("\t\tint {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 4) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 4);

continue;

}

if (field->type->name == "System.UInt32") {

io2 << std::format("\t\tstd::uint32_t {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 4) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 4);

continue;

}

if (field->type->name == "System.Boolean") {

io2 << std::format("\t\tbool {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 1) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 1);

continue;

}

if (field->type->name == "System.String") {

io2 << std::format("\t\tUnityResolve::UnityType::String* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "System.Single") {

io2 << std::format("\t\tfloat {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 4) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 4);

continue;

}

if (field->type->name == "System.Double") {

io2 << std::format("\t\tdouble {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > 8) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - 8);

continue;

}

if (field->type->name == "UnityEngine.Vector3") {

io2 << std::format("\t\tUnityResolve::UnityType::Vector3 {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Vector3)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Vector3));

continue;

}

if (field->type->name == "UnityEngine.Vector2") {

io2 << std::format("\t\tUnityResolve::UnityType::Vector2 {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Vector2)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Vector2));

continue;

}

if (field->type->name == "UnityEngine.Vector4") {

io2 << std::format("\t\tUnityResolve::UnityType::Vector4 {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Vector4)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Vector4));

continue;

}

if (field->type->name == "UnityEngine.GameObject") {

io2 << std::format("\t\tUnityResolve::UnityType::GameObject* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "UnityEngine.Transform") {

io2 << std::format("\t\tUnityResolve::UnityType::Transform* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "UnityEngine.Animator") {

io2 << std::format("\t\tUnityResolve::UnityType::Animator* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "UnityEngine.Physics") {

io2 << std::format("\t\tUnityResolve::UnityType::Physics* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "UnityEngine.Component") {

io2 << std::format("\t\tUnityResolve::UnityType::Component* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

if (field->type->name == "UnityEngine.Rect") {

io2 << std::format("\t\tUnityResolve::UnityType::Rect {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Rect)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Rect));

continue;

}

if (field->type->name == "UnityEngine.Quaternion") {

io2 << std::format("\t\tUnityResolve::UnityType::Quaternion {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Quaternion)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Quaternion));

continue;

}

if (field->type->name == "UnityEngine.Color") {

io2 << std::format("\t\tUnityResolve::UnityType::Color {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Color)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Color));

continue;

}

if (field->type->name == "UnityEngine.Matrix4x4") {

io2 << std::format("\t\tUnityResolve::UnityType::Matrix4x4 {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(UnityType::Matrix4x4)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(UnityType::Matrix4x4));

continue;

}

if (field->type->name == "UnityEngine.Rigidbody") {

io2 << std::format("\t\tUnityResolve::UnityType::Rigidbody* {};\n", name);

if (!pClass->fields[i + 1]->static_field && (pClass->fields[i + 1]->offset - field->offset) > sizeof(void*)) io2 << std::format("\t\tchar {}_[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset - sizeof(void*));

continue;

}

io2 << std::format("\t\tchar {}[0x{:06X}];\n", name, pClass->fields[i + 1]->offset - field->offset);

}

io2 << "\n";

io2 << "\t};\n\n";

}

}

io2 << '\n';

io2.close();

}

#endif

template <typename Return, typename... Args>

static auto Invoke(const std::string& funcName, Args... args) -> Return {

#if WINDOWS_MODE

if (!address_.contains(funcName) || !address_[funcName]) address_[funcName] = static_cast<void*>(GetProcAddress(static_cast<HMODULE>(hmodule_), funcName.c_str()));

#elif ANDROID_MODE || LINUX_MODE || IOS_MODE || HARMONYOS_MODE

if (address_.find(funcName) == address_.end() || !address_[funcName]) {

address_[funcName] = dlsym(hmodule_, funcName.c_str());

}

#endif

if (address_[funcName] != nullptr) {

try {

return reinterpret_cast<Return(UNITY_CALLING_CONVENTION*)(Args...)>(address_[funcName])(args...);

}

catch (...) {

return Return();

}

}

return Return();

}

inline static std::vector<Assembly*> assembly;

static auto Get(const std::string& strAssembly) -> Assembly* {

for (const auto pAssembly : assembly) if (pAssembly->name == strAssembly) return pAssembly;

return nullptr;

}

private:

static auto ForeachAssembly() -> void {

// 遍历程序集

if (mode_ == Mode::Il2Cpp) {

size_t nrofassemblies = 0;

const auto assemblies = Invoke<void**>("il2cpp_domain_get_assemblies", pDomain, &nrofassemblies);

for (auto i = 0; i < nrofassemblies; i++) {

const auto ptr = assemblies[i];

if (ptr == nullptr) continue;

auto assembly = new Assembly{ .address = ptr };

const auto image = Invoke<void*>("il2cpp_assembly_get_image", ptr);

assembly->file = Invoke<const char*>("il2cpp_image_get_filename", image);

assembly->name = Invoke<const char*>("il2cpp_image_get_name", image);

UnityResolve::assembly.push_back(assembly);

ForeachClass(assembly, image);

}

}

else {

Invoke<void*, void(*)(void* ptr, std::vector<Assembly*>&), std::vector<Assembly*>&>("mono_assembly_foreach",

[](void* ptr, std::vector<Assembly*>& v) {

if (ptr == nullptr) return;

auto assembly = new Assembly{ .address = ptr };

void* image;

try {

image = Invoke<void*>("mono_assembly_get_image", ptr);

assembly->file = Invoke<const char*>("mono_image_get_filename", image);

assembly->name = Invoke<const char*>("mono_image_get_name", image);

assembly->name += ".dll";

v.push_back(assembly);

}

catch (...) {

return;

}

ForeachClass(assembly, image);

},

assembly);

}

}

static auto ForeachClass(Assembly* assembly, void* image) -> void {

// 遍历类

if (mode_ == Mode::Il2Cpp) {

const auto count = Invoke<int>("il2cpp_image_get_class_count", image);

for (auto i = 0; i < count; i++) {

const auto pClass = Invoke<void*>("il2cpp_image_get_class", image, i);

if (pClass == nullptr) continue;

const auto pAClass = new Class();

pAClass->address = pClass;

pAClass->name = Invoke<const char*>("il2cpp_class_get_name", pClass);

if (const auto pPClass = Invoke<void*>("il2cpp_class_get_parent", pClass)) pAClass->parent = Invoke<const char*>("il2cpp_class_get_name", pPClass);

pAClass->namespaze = Invoke<const char*>("il2cpp_class_get_namespace", pClass);

assembly->classes.push_back(pAClass);

ForeachFields(pAClass, pClass);

ForeachMethod(pAClass, pClass);

void* i_class;

void* iter{};

do {

if ((i_class = Invoke<void*>("il2cpp_class_get_interfaces", pClass, &iter))) {

ForeachFields(pAClass, i_class);

ForeachMethod(pAClass, i_class);

}

} while (i_class);

}

}

else {

try {

const void* table = Invoke<void*>("mono_image_get_table_info", image, 2);

const auto count = Invoke<int>("mono_table_info_get_rows", table);

for (auto i = 0; i < count; i++) {

const auto pClass = Invoke<void*>("mono_class_get", image, 0x02000000 | (i + 1));

if (pClass == nullptr) continue;

const auto pAClass = new Class();

pAClass->address = pClass;

try {

pAClass->name = Invoke<const char*>("mono_class_get_name", pClass);

if (const auto pPClass = Invoke<void*>("mono_class_get_parent", pClass)) pAClass->parent = Invoke<const char*>("mono_class_get_name", pPClass);

pAClass->namespaze = Invoke<const char*>("mono_class_get_namespace", pClass);

assembly->classes.push_back(pAClass);

}

catch (...) {

return;

}

ForeachFields(pAClass, pClass);

ForeachMethod(pAClass, pClass);

void* iClass;

void* iiter{};

do {

try {

if ((iClass = Invoke<void*>("mono_class_get_interfaces", pClass, &iiter))) {

ForeachFields(pAClass, iClass);

ForeachMethod(pAClass, iClass);

}

}

catch (...) {

return;

}

} while (iClass);

}

}

catch (...) {}

}

}

static auto ForeachFields(Class* klass, void* pKlass) -> void {

// 遍历成员

if (mode_ == Mode::Il2Cpp) {

void* iter = nullptr;

void* field;

do {

if ((field = Invoke<void*>("il2cpp_class_get_fields", pKlass, &iter))) {

const auto pField = new Field{ .address = field, .name = Invoke<const char*>("il2cpp_field_get_name", field), .type = new Type{.address = Invoke<void*>("il2cpp_field_get_type", field)}, .klass = klass, .offset = Invoke<int>("il2cpp_field_get_offset", field), .static_field = false, .vTable = nullptr };

pField->static_field = pField->offset <= 0;

pField->type->name = Invoke<const char*>("il2cpp_type_get_name", pField->type->address);

pField->type->size = -1;

klass->fields.push_back(pField);

}

} while (field);

}

else {

void* iter = nullptr;

void* field;

do {

try {

if ((field = Invoke<void*>("mono_class_get_fields", pKlass, &iter))) {

const auto pField = new Field{ .address = field, .name = Invoke<const char*>("mono_field_get_name", field), .type = new Type{.address = Invoke<void*>("mono_field_get_type", field)}, .klass = klass, .offset = Invoke<int>("mono_field_get_offset", field), .static_field = false, .vTable = nullptr };

int tSize{};

/*pField->static_field = pField->offset <= 0;*/

int flags = Invoke<int>("mono_field_get_flags", field);

if (flags & 0x10)//0x10=FIELD_ATTRIBUTE_STATIC

{

pField->static_field = true;

}

pField->type->name = Invoke<const char*>("mono_type_get_name", pField->type->address);

pField->type->size = Invoke<int>("mono_type_size", pField->type->address, &tSize);

klass->fields.push_back(pField);

}

}

catch (...) {

return;

}

} while (field);

}

}

static auto ForeachMethod(Class* klass, void* pKlass) -> void {

// 遍历方法

if (mode_ == Mode::Il2Cpp) {

void* iter = nullptr;

void* method;

do {

if ((method = Invoke<void*>("il2cpp_class_get_methods", pKlass, &iter))) {

int fFlags{};

const auto pMethod = new Method{};

pMethod->address = method;

pMethod->name = Invoke<const char*>("il2cpp_method_get_name", method);

pMethod->klass = klass;

pMethod->return_type = new Type{ .address = Invoke<void*>("il2cpp_method_get_return_type", method), };

pMethod->flags = Invoke<int>("il2cpp_method_get_flags", method, &fFlags);

pMethod->static_function = pMethod->flags & 0x10;

pMethod->return_type->name = Invoke<const char*>("il2cpp_type_get_name", pMethod->return_type->address);

pMethod->return_type->size = -1;

pMethod->function = *static_cast<void**>(method);

klass->methods.push_back(pMethod);

const auto argCount = Invoke<int>("il2cpp_method_get_param_count", method);

for (auto index = 0; index < argCount; index++) pMethod->args.push_back(new Method::Arg{ Invoke<const char*>("il2cpp_method_get_param_name", method, index), new Type{.address = Invoke<void*>("il2cpp_method_get_param", method, index), .name = Invoke<const char*>("il2cpp_type_get_name", Invoke<void*>("il2cpp_method_get_param", method, index)), .size = -1} });

}

} while (method);

}

else {

void* iter = nullptr;

void* method;

do {

try {

if ((method = Invoke<void*>("mono_class_get_methods", pKlass, &iter))) {

const auto signature = Invoke<void*>("mono_method_signature", method);

if (!signature) continue;

int fFlags{};

const auto pMethod = new Method{};

pMethod->address = method;

char** names = nullptr;

try {

pMethod->name = Invoke<const char*>("mono_method_get_name", method);

pMethod->klass = klass;

pMethod->return_type = new Type{ .address = Invoke<void*>("mono_signature_get_return_type", signature) };

pMethod->flags = Invoke<int>("mono_method_get_flags", method, &fFlags);

pMethod->static_function = pMethod->flags & 0x10;

pMethod->return_type->name = Invoke<const char*>("mono_type_get_name", pMethod->return_type->address);

int tSize{};

pMethod->return_type->size = Invoke<int>("mono_type_size", pMethod->return_type->address, &tSize);

klass->methods.push_back(pMethod);

int param_count = Invoke<int>("mono_signature_get_param_count", signature);

names = new char* [param_count];

Invoke<void>("mono_method_get_param_names", method, names);

}

catch (...) {

continue;

}

void* mIter = nullptr;

void* mType;

int iname = 0;

do {

try {

if ((mType = Invoke<void*>("mono_signature_get_params", signature, &mIter))) {

int t_size{};

try {

pMethod->args.push_back(new Method::Arg{

names[iname],

new Type{.address = mType, .name = Invoke<const char*>("mono_type_get_name", mType), .size = Invoke<int>("mono_type_size", mType, &t_size) }

});

}

catch (...) {

}

iname++;

}

}

catch (...) {

break;

}

} while (mType);

}

}

catch (...) {

return;

}

} while (method);

}

}

public:

class UnityType final {

public:

using IntPtr = std::uintptr_t;

using Int32 = std::int32_t;

using Int64 = std::int64_t;

using Char = wchar_t;

using Int16 = std::int16_t;

using Byte = std::uint8_t;

#ifndef USE_GLM

struct Vector3;

struct Vector4;

struct Vector2;

struct Quaternion;

struct Matrix4x4;

#else

using Vector3 = glm::vec3;

using Vector2 = glm::vec2;

using Vector4 = glm::vec4;

using Quaternion = glm::quat;

using Matrix4x4 = glm::mat4x4;

#endif

struct Camera;

struct Transform;

struct Component;

struct UnityObject;

struct LayerMask;

struct Rigidbody;

struct Physics;

struct GameObject;

struct Collider;

struct Bounds;

struct Plane;

struct Ray;

struct Rect;

struct Color;

template <typename T>

struct Array;

struct String;

struct Object;

template <typename T>

struct List;

template <typename TKey, typename TValue>

struct Dictionary;

struct Behaviour;

struct MonoBehaviour;

struct CsType;

struct Mesh;

struct Renderer;

struct Animator;

struct CapsuleCollider;

struct BoxCollider;

struct FieldInfo;

struct MethodInfo;

struct PropertyInfo;

struct Assembly;

struct EventInfo;

struct MemberInfo;

struct Time;

struct RaycastHit;

#ifndef USE_GLM

struct Vector3 {

float x, y, z;

Vector3() { x = y = z = 0.f; }

Vector3(const float f1, const float f2, const float f3) {

x = f1;

y = f2;

z = f3;

}

[[nodiscard]] auto Length() const -> float { return x * x + y * y + z * z; }

[[nodiscard]] auto Dot(const Vector3 b) const -> float { return x * b.x + y * b.y + z * b.z; }

[[nodiscard]] auto Normalize() const -> Vector3 {

if (const auto len = Length(); len > 0) return Vector3(x / len, y / len, z / len);

return Vector3(x, y, z);

}

auto ToVectors(Vector3* m_pForward, Vector3* m_pRight, Vector3* m_pUp) const -> void {

constexpr auto m_fDeg2Rad = std::numbers::pi_v<float> / 180.F;

const auto m_fSinX = sinf(x * m_fDeg2Rad);

const auto m_fCosX = cosf(x * m_fDeg2Rad);

const auto m_fSinY = sinf(y * m_fDeg2Rad);

const auto m_fCosY = cosf(y * m_fDeg2Rad);

const auto m_fSinZ = sinf(z * m_fDeg2Rad);

const auto m_fCosZ = cosf(z * m_fDeg2Rad);

if (m_pForward) {

m_pForward->x = m_fCosX * m_fCosY;

m_pForward->y = -m_fSinX;

m_pForward->z = m_fCosX * m_fSinY;

}

if (m_pRight) {

m_pRight->x = -1.f * m_fSinZ * m_fSinX * m_fCosY + -1.f * m_fCosZ * -m_fSinY;

m_pRight->y = -1.f * m_fSinZ * m_fCosX;

m_pRight->z = -1.f * m_fSinZ * m_fSinX * m_fSinY + -1.f * m_fCosZ * m_fCosY;

}

if (m_pUp) {

m_pUp->x = m_fCosZ * m_fSinX * m_fCosY + -m_fSinZ * -m_fSinY;

m_pUp->y = m_fCosZ * m_fCosX;

m_pUp->z = m_fCosZ * m_fSinX * m_fSinY + -m_fSinZ * m_fCosY;

}

}