Merge branch 'praydog:master' into master

Author: joeyhodge

.github/workflows/dev-release.yml

@@ -17,7 +17,7 @@ jobs:
           persist-credentials: false
 
       - name: Configure CMake
-        run: cmake -S ${{github.workspace}} -B ${{github.workspace}}/build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DDEVELOPER_MODE=ON
+        run: cmake -S ${{github.workspace}} -B ${{github.workspace}}/build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DDEVELOPER_MODE=ON "-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
 
       - name: Build
         run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target ${{matrix.target}}

shared/sdk/REContext.cpp

@@ -821,6 +821,69 @@ namespace sdk {
         return create_instance_method->call<sdk::SystemArray*>(sdk::get_thread_context(), runtime_type, length);
     }
 
+    sdk::Delegate* VM::create_delegate(sdk::RETypeDefinition* t, uint32_t num_methods) {
+        if (t == nullptr) {
+            return nullptr;
+        }
+
+        static const auto delegate_type = sdk::find_type_definition("System.Delegate");
+        static const auto combine_method = delegate_type->get_method("Combine(System.Delegate, System.Delegate)");
+
+        if (combine_method == nullptr) {
+            return nullptr;
+        }
+
+        ::REObjectInfo fake_object_info {
+            .classInfo = (::REClassInfo*)t,
+        };
+
+        sdk::Delegate fake_delegate_non_empty {
+            .num_methods = 1,
+        };
+
+        fake_delegate_non_empty.info = &fake_object_info;
+
+        sdk::Delegate fake_delegate_empty = fake_delegate_non_empty;
+        fake_delegate_empty.num_methods = 0;
+
+        sdk::Delegate* new_delegate = &fake_delegate_empty;
+
+        auto ctx = sdk::get_thread_context();
+
+        for (uint32_t i = 0; i < num_methods; ++i) {
+            const auto previous_delegate = new_delegate;
+            new_delegate = combine_method->call<sdk::Delegate*>(ctx, new_delegate, &fake_delegate_non_empty);
+
+            if (new_delegate == nullptr) {
+                spdlog::error("[VM::create_delegate] Unable to create delegate.");
+                return nullptr;
+            }
+        }
+
+        if (new_delegate == nullptr || new_delegate == &fake_delegate_empty) {
+            spdlog::error("[VM::create_delegate] Unable to create delegate.");
+            return nullptr;
+        }
+
+        return new_delegate;
+    }
+
+    sdk::Delegate* VM::create_delegate(::REManagedObject* runtime_type, uint32_t num_methods) {
+        if (runtime_type == nullptr) {
+            return nullptr;
+        }
+
+        static auto runtime_type_t = sdk::find_type_definition("System.RuntimeType");
+        static auto get_TypeHandle = runtime_type_t->get_method("get_TypeHandle");
+
+        if (get_TypeHandle == nullptr) {
+            return nullptr;
+        }
+
+        auto type_handle = (sdk::RETypeDefinition*)get_TypeHandle->invoke(runtime_type).ptr;
+        return create_delegate(type_handle, num_methods);
+    }
+
     ::REManagedObject* VM::create_sbyte(int8_t value)  {
         static auto sbyte_type = ::sdk::find_type_definition("System.SByte");
         static auto value_field = [&]() {

shared/sdk/REContext.hpp

@@ -35,6 +35,19 @@ struct REStaticTbl {
     uint32_t size;
 };
 
+struct DelegateInvocation {
+    using InvocationFn = void (*)(void*, void*, void*);
+    
+    REManagedObject* object;
+    InvocationFn* func;
+    sdk::REMethodDefinition* method;
+};
+
+struct Delegate : public REManagedObject {
+    uint32_t num_methods{0};
+    DelegateInvocation methods[1];
+};
+
 // AKA via.clr.VM
 #if TDB_VER <= 49
 class VM : public regenny::via::clr::VM {
@@ -55,6 +68,8 @@ class VM {
     static sdk::InvokeMethod* get_invoke_table();
     static SystemString* create_managed_string(std::wstring_view str); // System.String
     static sdk::SystemArray* create_managed_array(::REManagedObject* runtime_type, uint32_t length); // System.Array
+    static sdk::Delegate* create_delegate(sdk::RETypeDefinition* t, uint32_t num_methods); // System.Delegate
+    static sdk::Delegate* create_delegate(::REManagedObject* runtime_type, uint32_t num_methods); // System.Delegate
 
     static ::REManagedObject* create_sbyte(int8_t value); // System.SByte
     static ::REManagedObject* create_byte(uint8_t value); // System.Byte

src/mods/bindings/Sdk.cpp

@@ -583,6 +583,36 @@ sol::object create_managed_array(sol::this_state s, sol::object t_obj, uint32_t
     return sol::make_object(s, (::sdk::SystemArray*)out);
 }
 
+sol::object create_delegate(sol::this_state s, sol::object t_obj, uint32_t num_methods) {
+    ::REManagedObject* t{nullptr};
+
+    if (t_obj.is<::REManagedObject*>()) {
+        t = t_obj.as<::REManagedObject*>();
+    } else if (t_obj.is<::sdk::RETypeDefinition*>()) {
+        t = t_obj.as<::sdk::RETypeDefinition*>()->get_runtime_type();
+    } else if (t_obj.is<const char*>()) {
+        const auto tdef = ::sdk::find_type_definition(t_obj.as<const char*>());
+
+        if (tdef != nullptr) {
+            t = tdef->get_runtime_type();
+        }
+    } else {
+        throw sol::error("Invalid type passed to create_delegate. Must be a runtime type, a type definition, or a type name.");
+    }
+
+    if (t == nullptr) {
+        throw sol::error("Type passed to create_delegate resolved to null.");
+    }
+
+    auto out = ::sdk::VM::create_delegate(t, num_methods);
+
+    if (out == nullptr) {
+        return sol::make_object(s, sol::nil);
+    }
+
+    return sol::make_object(s, (::REManagedObject*)out);
+}
+
 sol::object create_sbyte(sol::this_state s, int8_t value) {
     auto new_obj = ::sdk::VM::create_sbyte(value);
 
@@ -1435,6 +1465,7 @@ void bindings::open_sdk(ScriptState* s) {
     sdk["get_managed_singleton"] = api::sdk::get_managed_singleton;
     sdk["create_managed_string"] = api::sdk::create_managed_string;
     sdk["create_managed_array"] = api::sdk::create_managed_array;
+    sdk["create_delegate"] = api::sdk::create_delegate;
     sdk["create_sbyte"] = api::sdk::create_sbyte;
     sdk["create_byte"] = api::sdk::create_byte;
     sdk["create_int16"] = api::sdk::create_int16;

src/mods/tools/GameObjectsDisplay.cpp

@@ -15,19 +15,6 @@
 #include "../BackBufferRenderer.hpp"
 #include "GameObjectsDisplay.hpp"
 
-namespace detail {
-struct Invocation {
-    void* object_ptr;
-    void* method_ptr;
-    void* unk;
-};
-
-struct Predicate : public REManagedObject {
-    uint32_t num_invocations{0};
-    std::array<Invocation, 10> invocations;
-};
-}
-
 std::optional<std::string> GameObjectsDisplay::on_initialize_d3d_thread() {
     return initialize_d3d_resources();
 }