Port/inputsource: Refactor Abstracted Input Handler

UE4SS/include/ExceptionHandling.hpp

@@ -8,11 +8,11 @@
 #define UE4SS_ERROR_OUTPUTTER()                                                                                                                                \
     if (!Output::has_internal_error())                                                                                                                         \
     {                                                                                                                                                          \
-        Output::send<LogLevel::Error>(STR("Error: {}\n"), to_wstring(e.what()));                                                                               \
+        Output::send<LogLevel::Error>(SYSSTR("Error: {}\n"), to_system(e.what()));                                                                             \
     }                                                                                                                                                          \
     else                                                                                                                                                       \
     {                                                                                                                                                          \
-        printf_s("Internal Error: %s\n", e.what());                                                                                                            \
+        fprintf(stderr, "Internal Error: %s\n", e.what());                                                                                                     \
     }
 
 namespace RC

UE4SS/include/GUI/ConsoleOutputDevice.hpp

@@ -30,7 +30,7 @@ namespace RC::Output
 
       public:
         auto has_optional_arg() const -> bool override;
-        auto receive(File::StringViewType fmt) const -> void override;
-        auto receive_with_optional_arg(File::StringViewType fmt, int32_t optional_arg = 0) const -> void override;
+        auto receive(SystemStringViewType fmt) const -> void override;
+        auto receive_with_optional_arg(SystemStringViewType fmt, int32_t optional_arg = 0) const -> void override;
     };
 } // namespace RC::Output

UE4SS/include/GUI/GUITab.hpp

@@ -22,12 +22,12 @@ namespace RC::GUI
       private:
         RenderFunctionType render_function{};
         CppUserModBase* owner{};
-        StringType tab_name{};
+        UEStringType tab_name{};
 
       public:
         GUITab() = delete;
-        GUITab(StringViewType name, RenderFunctionType render_function) : tab_name(name), render_function(render_function){};
-        GUITab(StringViewType name, RenderFunctionType render_function, CppUserModBase* owner)
+        GUITab(UEStringViewType name, RenderFunctionType render_function) : tab_name(name), render_function(render_function){};
+        GUITab(UEStringViewType name, RenderFunctionType render_function, CppUserModBase* owner)
             : tab_name(name), render_function(render_function), owner(owner){};
         ~GUITab() = default;
 

UE4SS/include/GUI/LiveView.hpp

@@ -61,9 +61,9 @@ namespace RC::GUI
             Output::Targets<Output::FileDevice> output{};
             FProperty* property{};
             UObject* container{};
-            StringType object_name{};
-            StringType property_name{};
-            StringType property_value{};
+            UEStringType object_name{};
+            UEStringType property_name{};
+            UEStringType property_value{};
             size_t hash{};
             std::string history{};
             float history_previous_max_scroll_y{};
@@ -77,7 +77,7 @@ namespace RC::GUI
             std::pair<int, int> function_hook_ids{};
 
             Watch() = delete;
-            Watch(StringType&& object_name, StringType&& property_name);
+            Watch(UEStringType&& object_name, UEStringType&& property_name);
         };
 
       private:

UE4SS/include/GUI/LiveView/Filter/ClassNamesFilter.hpp

@@ -8,9 +8,9 @@ namespace RC::GUI::Filter
     class ClassNamesFilter
     {
       public:
-        static inline StringType s_debug_name{STR("ClassNamesFilter")};
+        static inline UEStringType s_debug_name{STR("ClassNamesFilter")};
         static inline std::string s_internal_class_names{};
-        static inline std::vector<StringType> list_class_names;
+        static inline std::vector<UEStringType> list_class_names;
         static inline bool b_is_exclude{true};
 
         static auto post_eval(UObject* object) -> bool

UE4SS/include/GUI/LiveView/Filter/DefaultObjectsOnly.hpp

@@ -7,7 +7,7 @@ namespace RC::GUI::Filter
     class DefaultObjectsOnly
     {
       public:
-        static inline StringType s_debug_name{STR("DefaultObjectsOnly")};
+        static inline UEStringType s_debug_name{STR("DefaultObjectsOnly")};
         static inline bool s_enabled{};
 
         static auto pre_eval(UObject* object) -> bool

UE4SS/include/GUI/LiveView/Filter/ExcludeClassName.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <GUI/LiveView/Filter/SearchFilter.hpp>
+#include <Unreal/UClass.hpp>
+
+namespace RC::GUI::Filter
+{
+    class ExcludeClassName
+    {
+      public:
+        static inline UEStringType s_debug_name{STR("ExcludeClassName")};
+        static inline UEStringType s_value{};
+        static inline std::string s_internal_value{};
+
+        static auto post_eval(UObject* object) -> bool
+        {
+            if (!s_value.empty())
+            {
+                auto class_name = object->GetClassPrivate()->GetName();
+                auto pos = class_name.find(s_value);
+                return pos != class_name.npos;
+            }
+            else
+            {
+                return false;
+            }
+        }
+    };
+} // namespace RC::GUI::Filter

UE4SS/include/GUI/LiveView/Filter/FunctionParamFlags.hpp

@@ -9,7 +9,7 @@ namespace RC::GUI::Filter
     class FunctionParamFlags
     {
       public:
-        static inline StringType s_debug_name{STR("FunctionParamFlags")};
+        static inline UEStringType s_debug_name{STR("FunctionParamFlags")};
         static inline bool s_enabled{};
         static inline std::array<bool, 255> s_checkboxes{};
         static inline EPropertyFlags s_value{};

UE4SS/include/GUI/LiveView/Filter/HasProperty.hpp

@@ -8,9 +8,9 @@ namespace RC::GUI::Filter
     class HasProperty
     {
       public:
-        static inline StringType s_debug_name{STR("HasProperty")};
+        static inline UEStringType s_debug_name{STR("HasProperty")};
         static inline std::string s_internal_properties{};
-        static inline std::vector<StringType> list_properties{};
+        static inline std::vector<UEStringType> list_properties{};
 
         static auto post_eval(UObject* object) -> bool
         {

UE4SS/include/GUI/LiveView/Filter/HasPropertyType.hpp

@@ -10,7 +10,7 @@ namespace RC::GUI::Filter
     class HasPropertyType
     {
       public:
-        static inline StringType s_debug_name{STR("HasPropertyType")};
+        static inline UEStringType s_debug_name{STR("HasPropertyType")};
         static inline std::string s_internal_property_types{};
         static inline std::vector<FName> list_property_types{};
 

UE4SS/include/GUI/LiveView/Filter/IncludeDefaultObjects.hpp

@@ -7,7 +7,7 @@ namespace RC::GUI::Filter
     class IncludeDefaultObjects
     {
       public:
-        static inline StringType s_debug_name{STR("IncludeDefaultObjects")};
+        static inline UEStringType s_debug_name{STR("IncludeDefaultObjects")};
         static inline bool s_enabled{true};
 
         static auto pre_eval(UObject* object) -> bool

UE4SS/include/GUI/LiveView/Filter/InstancesOnly.hpp

@@ -7,7 +7,7 @@ namespace RC::GUI::Filter
     class InstancesOnly
     {
       public:
-        static inline StringType s_debug_name{STR("InstancesOnly")};
+        static inline UEStringType s_debug_name{STR("InstancesOnly")};
         static inline bool s_enabled{};
         static auto pre_eval(UObject* object) -> bool
         {

UE4SS/include/GUI/LiveView/Filter/NonInstancesOnly.hpp

@@ -8,7 +8,7 @@ namespace RC::GUI::Filter
     class NonInstancesOnly
     {
       public:
-        static inline StringType s_debug_name{STR("NonInstancesOnly")};
+        static inline UEStringType s_debug_name{STR("NonInstancesOnly")};
         static inline bool s_enabled{};
 
         static auto pre_eval(UObject* object) -> bool

UE4SS/include/LuaCustomMemberFunctions.hpp

@@ -49,9 +49,9 @@ namespace RC::LuaBackCompat
 
     // Backwards compatibility with UE4SS 1.3.
 
-    auto StaticFindObject(UClass* ObjectClass, UObject* InObjectPackage, const wchar_t* OrigInName, bool bExactClass = false) -> UObject*;
-    auto StaticFindObject(const wchar_t* OrigInName) -> UObject*;
-    auto NotifyOnNewObject(const wchar_t* class_name, std::function<void(UObject*)>& callable) -> void;
+    auto StaticFindObject(UClass* ObjectClass, UObject* InObjectPackage, const UECharType* OrigInName, bool bExactClass = false) -> UObject*;
+    auto StaticFindObject(const UECharType* OrigInName) -> UObject*;
+    auto NotifyOnNewObject(const UECharType* class_name, std::function<void(UObject*)>& callable) -> void;
 
     auto lua_RegisterHook_wrapper(lua_State*) -> int;
     auto lua_UObjectBase_IsA_wrapper(lua_State*) -> int;

UE4SS/include/LuaType/LuaCustomProperty.hpp

@@ -4,6 +4,8 @@
 #include <string>
 #include <vector>
 
+#include <File/Macros.hpp>
+
 namespace RC::Unreal
 {
     class UObject;
@@ -17,11 +19,11 @@ namespace RC::LuaType
     class LuaCustomProperty
     {
       public:
-        std::wstring m_name{};
+        SystemStringType m_name{};
         std::unique_ptr<Unreal::CustomProperty> m_property;
 
       public:
-        LuaCustomProperty(std::wstring name, std::unique_ptr<Unreal::CustomProperty> property);
+        LuaCustomProperty(SystemStringType name, std::unique_ptr<Unreal::CustomProperty> property);
 
       private:
         class PropertyList
@@ -30,9 +32,9 @@ namespace RC::LuaType
             std::vector<LuaCustomProperty> properties;
 
           public:
-            auto add(std::wstring property_name, std::unique_ptr<Unreal::CustomProperty>) -> void;
+            auto add(SystemStringType property_name, std::unique_ptr<Unreal::CustomProperty>) -> void;
             auto clear() -> void;
-            auto find_or_nullptr(Unreal::UObject* base, std::wstring property_name) -> Unreal::FProperty*;
+            auto find_or_nullptr(Unreal::UObject* base, SystemStringType property_name) -> Unreal::FProperty*;
         };
 
       public:

UE4SS/include/LuaType/LuaUObject.hpp

@@ -462,7 +462,7 @@ namespace RC::LuaType
                     {
                         lua.throw_error("Function 'GetProperty' requires a string as the first parameter");
                     }
-                    std::wstring property_name = to_wstring(lua.get_string(2));
+                    auto property_name = to_system(lua.get_string(2));
 
                     auto reflection_table = lua.get_table();
                     const auto& reflected_object = reflection_table.get_userdata_field<SelfType>("ReflectedObject").get_remote_cpp_object();
@@ -478,7 +478,7 @@ namespace RC::LuaType
                     {
                         obj_as_struct = reflected_object->GetClassPrivate();
                     }
-                    auto* property = obj_as_struct->FindProperty(Unreal::FName(property_name));
+                    auto* property = obj_as_struct->FindProperty(Unreal::FName(to_ue(property_name)));
 
                     construct_xproperty(lua, property);
                     return 1;
@@ -586,7 +586,7 @@ No overload found for function 'UObject.ProcessConsoleExec'.
                 {
                     lua.throw_error(error_overload_not_found);
                 }
-                auto cmd = to_wstring(lua.get_string());
+                auto cmd = to_system(lua.get_string());
 
                 if (lua.get_stack_size() < 2)
                 {
@@ -601,7 +601,7 @@ No overload found for function 'UObject.ProcessConsoleExec'.
                 auto executor = lua.get_userdata<LuaType::UObject>();
 
                 auto ar = Unreal::FOutputDevice{};
-                auto return_value = lua_object.get_remote_cpp_object()->ProcessConsoleExec(cmd.c_str(), ar, executor.get_remote_cpp_object());
+                auto return_value = lua_object.get_remote_cpp_object()->ProcessConsoleExec(to_ue_string(cmd).c_str(), ar, executor.get_remote_cpp_object());
 
                 lua.set_bool(return_value);
                 return 1;
@@ -641,7 +641,7 @@ No overload found for function 'UObject.ProcessConsoleExec'.
         {
             auto& lua_object = lua.get_userdata<SelfType>();
 
-            const std::wstring& member_name = to_const_wstring(lua.get_string());
+            auto member_name = to_system_string(lua.get_string());
 
             // If nullptr then we assume the UObject wasn't found so lets return an invalid UObject to Lua
             // This allows the safe chaining of "__index" as long as the Lua script checks ":IsValid()" before using the object
@@ -656,17 +656,17 @@ No overload found for function 'UObject.ProcessConsoleExec'.
                     SelfType::construct(lua, static_cast<DerivedType*>(nullptr));
                     break;
                 case Operation::Set:
-                    Output::send(STR("[Lua][Error] Tried setting member variable '{}' but UObject instance is nullptr\n"), member_name);
+                    Output::send(SYSSTR("[Lua][Error] Tried setting member variable '{}' but UObject instance is nullptr\n"), member_name);
                     break;
                 default:
-                    Output::send(STR("[Lua][Error] The UObject instance is nullptr & operation type was invalid\n"));
+                    Output::send(SYSSTR("[Lua][Error] The UObject instance is nullptr & operation type was invalid\n"));
                     break;
                 }
 
                 return;
             }
 
-            Unreal::FName property_name = Unreal::FName(member_name);
+            Unreal::FName property_name = Unreal::FName(to_ue(member_name));
             Unreal::FField* field = LuaCustomProperty::StaticStorage::property_list.find_or_nullptr(lua_object.get_remote_cpp_object(), member_name);
 
             if (!field)
@@ -777,10 +777,10 @@ No overload found for function 'UObject.ProcessConsoleExec'.
             {
                 // We can either throw an error and kill the execution
                 /**/
-                std::wstring property_type_name = property_type.ToString();
+                auto property_type_name = to_string(property_type.ToString());
                 lua.throw_error(std::format(
                         "[LocalUnrealParam::prepare_to_handle] Tried accessing unreal property without a registered handler. Property type '{}' not supported.",
-                        to_string(property_type_name)));
+                        property_type_name));
                 //*/
 
                 // Or we can treat unhandled property types as some sort of generic type

UE4SS/include/Mod/CppMod.hpp

@@ -22,7 +22,7 @@ namespace RC
         typedef void (*uninstall_type)(CppUserModBase*);
 
       private:
-        std::wstring m_dlls_path;
+        SystemStringType m_dlls_path;
 
         HMODULE m_main_dll_module = NULL;
         DLL_DIRECTORY_COOKIE m_dlls_path_cookie = NULL;
@@ -32,7 +32,7 @@ namespace RC
         CppUserModBase* m_mod = nullptr;
 
       public:
-        CppMod(UE4SSProgram&, std::wstring&& mod_name, std::wstring&& mod_path);
+        CppMod(UE4SSProgram&, SystemStringType&& mod_name, SystemStringType&& mod_path);
         CppMod(CppMod&) = delete;
         CppMod(CppMod&&) = delete;
         ~CppMod() override;
@@ -41,7 +41,7 @@ namespace RC
         auto start_mod() -> void override;
         auto uninstall() -> void override;
 
-        auto fire_on_lua_start(StringViewType mod_name,
+        auto fire_on_lua_start(SystemStringViewType mod_name,
                                LuaMadeSimple::Lua& lua,
                                LuaMadeSimple::Lua& main_lua,
                                LuaMadeSimple::Lua& async_lua,
@@ -50,7 +50,7 @@ namespace RC
         auto fire_on_lua_start(LuaMadeSimple::Lua& lua, LuaMadeSimple::Lua& main_lua, LuaMadeSimple::Lua& async_lua, std::vector<LuaMadeSimple::Lua*>& hook_luas)
                 -> void;
 
-        auto fire_on_lua_stop(StringViewType mod_name,
+        auto fire_on_lua_stop(SystemStringViewType mod_name,
                               LuaMadeSimple::Lua& lua,
                               LuaMadeSimple::Lua& main_lua,
                               LuaMadeSimple::Lua& async_lua,
@@ -63,6 +63,6 @@ namespace RC
         auto fire_ui_init() -> void override;
         auto fire_program_start() -> void override;
         auto fire_update() -> void override;
-        auto fire_dll_load(std::wstring_view dll_name) -> void;
+        auto fire_dll_load(SystemStringViewType dll_name) -> void;
     };
 } // namespace RC