UIIl2cpp.hpp

#pragma once
 
#include "../Utils/Delegate.hpp"
#include "../Utils/Il2cpp.hpp"
#include "../Utils/MonoPtr.hpp"
 
#include <custom-types/shared/delegate.hpp>
#include <UnityEngine/Object.hpp>
#include <UnityEngine/Events/UnityAction.hpp>
#include <UnityEngine/Events/UnityAction_1.hpp>
#include <UnityEngine/Events/UnityAction_2.hpp>
#include <UnityEngine/Events/UnityAction_3.hpp>
#include <UnityEngine/Events/UnityAction_4.hpp>
#include <UnityEngine/UI/Button_ButtonClickedEvent.hpp>
 
namespace CP_SDK::UI {
 
    template<class t_Type>
    using UIFieldRef = Utils::MonoPtr<t_Type>&;
 
 
    template<class t_Type>
    using UIFieldRefDel = Utils::Func<UIFieldRef<t_Type>>;
 
 
    template<class t_Type>
    struct UIFieldDefault
    {
        static_assert(std::is_assignable_v<UnityEngine::Object, t_Type>);
        static Utils::MonoPtr<t_Type> Value;
    };
    template<class t_Type> Utils::MonoPtr<t_Type> UIFieldDefault<t_Type>::Value;
 
 
    template<class t_Type> struct UIFieldRefDelExtractor;
    template<class t_Type> struct UIFieldRefDelExtractor<Utils::Func<Utils::MonoPtr<t_Type>&>>
    {
        using t_PtrType = UIFieldRef<t_Type>;
        using t_DelType = UIFieldRefDel<t_Type>;
    };
 
 
    #define CP_SDK_UI_IL2CPP_BIND_FIELD(__Field, __Variable) __Field = [this]() -> CP_SDK::UI::UIFieldRefDelExtractor<typeof(__Field)>::t_PtrType { return __Variable; };
 
 
    template <typename t_Type, typename t_DelegateType>
    inline t_Type CustomTypesMakeDelegate(t_DelegateType p_Delegate)
    {
        return custom_types::MakeDelegate<t_Type>(p_Delegate);
    }
 
    template<typename... t_Args>
    auto MakeUnityAction(std::function<void(t_Args...)> p_Delegate)
    {
        constexpr int l_ArgCount = sizeof...(t_Args);
 
             if constexpr (l_ArgCount == 0) return CustomTypesMakeDelegate<UnityEngine::Events::UnityAction*>(p_Delegate);
        else if constexpr (l_ArgCount == 1) return CustomTypesMakeDelegate<UnityEngine::Events::UnityAction_1<t_Args...>*>(p_Delegate);
        else if constexpr (l_ArgCount == 2) return CustomTypesMakeDelegate<UnityEngine::Events::UnityAction_2<t_Args...>*>(p_Delegate);
        else if constexpr (l_ArgCount == 3) return CustomTypesMakeDelegate<UnityEngine::Events::UnityAction_3<t_Args...>*>(p_Delegate);
        else if constexpr (l_ArgCount == 4) return CustomTypesMakeDelegate<UnityEngine::Events::UnityAction_4<t_Args...>*>(p_Delegate);
 
        static_assert(l_ArgCount <= 4, "argument count was greater than supported");
    }
    template<typename t_Type, typename...t_Args>
    requires(std::is_constructible_v<std::function<void(t_Args...)>, t_Type> && !std::is_same_v<std::function<void(t_Args...)>, t_Type>)
    auto MakeUnityAction(t_Type p_Delegate)
    {
        return MakeUnityAction<t_Args...>(std::function<void(t_Args...)>(p_Delegate));
    }
    template<typename...t_Args>
    auto MakeUnityAction(Il2CppObject* p_Instance, const MethodInfo* p_MethodInfo)
    {
        if (p_MethodInfo->parameters_count != sizeof...(t_Args))
            throw std::runtime_error("Argcount mismatch between p_MethodInfo and t_Args");
 
        return MakeUnityAction<t_Args...>(std::function<void(t_Args...)>([p_Instance, p_MethodInfo](t_Args... p_Args){
            il2cpp_utils::RunMethod(p_Instance, p_MethodInfo, p_Args...);
        }));
    }
 
}