add IGNORE_STRUCT sentinel

also log python errors which occur during initalization, since I may have caused some :)

Author: apple1417

src/pyunrealsdk/dllmain.cpp

@@ -1,4 +1,5 @@
 #include "pyunrealsdk/pch.h"
+#include "pyunrealsdk/logging.h"
 #include "pyunrealsdk/pyunrealsdk.h"
 
 #ifdef PYUNREALSDK_INTERNAL
@@ -16,6 +17,7 @@ DWORD WINAPI startup_thread(LPVOID /*unused*/) {
         pyunrealsdk::init();
     } catch (std::exception& ex) {
         LOG(ERROR, "Exception occurred while initializing the python sdk: {}", ex.what());
+        pyunrealsdk::logging::log_python_exception(ex);
     }
 
     return 1;

src/pyunrealsdk/unreal_bindings/property_access.cpp

@@ -3,8 +3,10 @@
 #include "pyunrealsdk/static_py_object.h"
 #include "pyunrealsdk/unreal_bindings/uenum.h"
 #include "pyunrealsdk/unreal_bindings/wrapped_array.h"
+#include "pyunrealsdk/unreal_bindings/wrapped_struct.h"
 #include "unrealsdk/unreal/cast.h"
 #include "unrealsdk/unreal/classes/properties/uarrayproperty.h"
+#include "unrealsdk/unreal/classes/properties/ustructproperty.h"
 #include "unrealsdk/unreal/classes/uconst.h"
 #include "unrealsdk/unreal/classes/uenum.h"
 #include "unrealsdk/unreal/classes/ufield.h"
@@ -140,6 +142,9 @@ py::object py_getattr(UField* field,
                                                      field->Name, field->Class->Name));
 }
 
+// The templated lambda and all the if constexprs make everything have a really high penalty
+// Yes it's probably a bit complex, but it's also a bit awkward trying to split it up
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
 void py_setattr_direct(UField* field, uintptr_t base_addr, const py::object& value) {
     if (!field->is_instance(find_class<UProperty>())) {
         throw py::attribute_error(unrealsdk::fmt::format(
@@ -204,6 +209,13 @@ void py_setattr_direct(UField* field, uintptr_t base_addr, const py::object& val
         }
 
         for (size_t i = 0; i < seq_size; i++) {
+            // If we're setting a struct property, we might be being told to ignore it
+            if constexpr (std::is_base_of_v<UStructProperty, T>) {
+                if (is_ignore_struct_sentinel(value_seq[i])) {
+                    continue;
+                }
+            }
+
             set_property<T>(prop, i, base_addr, py::cast<value_type>(value_seq[i]));
         }
     });

src/pyunrealsdk/unreal_bindings/wrapped_struct.cpp

@@ -16,6 +16,23 @@ using namespace unrealsdk::unreal;
 
 namespace pyunrealsdk::unreal {
 
+namespace {
+
+/**
+ * @brief Gets the ignore struct sentinel.
+ *
+ * @return The ignore struct sentinel.
+ */
+py::object get_ignore_struct_sentinel(void) {
+    PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> storage;
+    return storage
+        .call_once_and_store_result(
+            []() { return py::module_::import("builtins").attr("object")(); })
+        .get_stored();
+}
+
+}  // namespace
+
 WrappedStruct make_struct(
     std::variant<const unrealsdk::unreal::UFunction*, const unrealsdk::unreal::UScriptStruct*> type,
     const py::args& args,
@@ -244,6 +261,12 @@ void register_wrapped_struct(py::module_& mod) {
             "Returns:\n"
             "    This struct's address.")
         .def_readwrite("_type", &WrappedStruct::type);
+
+    mod.attr("IGNORE_STRUCT") = get_ignore_struct_sentinel();
+}
+
+bool is_ignore_struct_sentinel(const py::object& obj) {
+    return obj.is(get_ignore_struct_sentinel());
 }
 
 }  // namespace pyunrealsdk::unreal

src/pyunrealsdk/unreal_bindings/wrapped_struct.h

@@ -39,6 +39,14 @@ void make_struct(unrealsdk::unreal::WrappedStruct& out_struct,
                  const py::args& args,
                  const py::kwargs& kwargs);
 
+/**
+ * @brief Checks if a python object is the ignore struct sentinel.
+ *
+ * @param obj The object to check.
+ * @return True if the object is the ignore struct sentinel.
+ */
+bool is_ignore_struct_sentinel(const py::object& obj);
+
 }  // namespace pyunrealsdk::unreal
 
 #endif

stubs/unrealsdk/unreal/__init__.pyi

@@ -48,9 +48,10 @@ from ._uobject_children import (
 from ._weak_pointer import WeakPointer
 from ._wrapped_array import WrappedArray
 from ._wrapped_multicast_delegate import WrappedMulticastDelegate
-from ._wrapped_struct import WrappedStruct
+from ._wrapped_struct import IGNORE_STRUCT, WrappedStruct
 
 __all__: tuple[str, ...] = (
+    "IGNORE_STRUCT",
     "BoundFunction",
     "UArrayProperty",
     "UBlueprintGeneratedClass",

stubs/unrealsdk/unreal/_wrapped_struct.pyi

@@ -4,6 +4,11 @@ from typing import Any
 
 from ._uobject_children import UField, UFunction, UScriptStruct, UStruct
 
+# A sentinel value which can be assigned to any struct property, but which does nothing.
+# This is most useful when a function has a required struct arg, but you want to use the default,
+# zero-init, value.
+IGNORE_STRUCT: object
+
 class WrappedStruct:
     _type: UStruct