#include "UnrealEnginePythonPrivatePCH.h"

#include "PythonDelegate.h"

#include "PythonFunction.h"

#if WITH_EDITOR

#include "Runtime/AssetRegistry/Public/AssetRegistryModule.h"

#include "ObjectTools.h"

#include "UnrealEd.h"

#endif

PyObject *py_ue_get_class(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

ue_PyUObject *ret = ue_get_python_wrapper(self->ue_object->GetClass());

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

PyObject *py_ue_class_generated_by(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

return PyErr_Format(PyExc_Exception, "uobject is a not a UClass");

UObject *u_object = u_class->ClassGeneratedBy;

if (!u_object)

Py_RETURN_NONE;

ue_PyUObject *ret = ue_get_python_wrapper(u_object);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

PyObject *py_ue_class_get_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

return PyErr_Format(PyExc_Exception, "uobject is a not a UClass");

return PyLong_FromUnsignedLongLong((uint64)u_class->GetClassFlags());

}

PyObject *py_ue_class_set_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

uint64 flags;

if (!PyArg_ParseTuple(args, "K:class_set_flags", &flags))

{

return nullptr;

}

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

return PyErr_Format(PyExc_Exception, "uobject is a not a UClass");

u_class->ClassFlags = (EClassFlags)flags;

Py_RETURN_NONE;

}

#if WITH_EDITOR

PyObject *py_ue_class_set_config_name(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *config_name;

if (!PyArg_ParseTuple(args, "s:class_set_config_name", &config_name))

{

return nullptr;

}

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

return PyErr_Format(PyExc_Exception, "uobject is a not a UClass");

u_class->ClassConfigName = UTF8_TO_TCHAR(config_name);

Py_RETURN_NONE;

}

PyObject *py_ue_class_get_config_name(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

return PyErr_Format(PyExc_Exception, "uobject is a not a UClass");

return PyUnicode_FromString(TCHAR_TO_UTF8(*u_class->ClassConfigName.ToString()));

}

#endif

PyObject *py_ue_get_property_struct(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *property_name;

if (!PyArg_ParseTuple(args, "s:get_property_struct", &property_name))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

UStructProperty *prop = Cast<UStructProperty>(u_property);

if (!prop)

return PyErr_Format(PyExc_Exception, "object is not a StructProperty");

return py_ue_new_uscriptstruct(prop->Struct, prop->ContainerPtrToValuePtr<uint8>(self->ue_object));

}

PyObject *py_ue_get_super_class(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_class = (UClass *)self->ue_object;

}

else

{

u_class = self->ue_object->GetClass();

}

ue_PyUObject *ret = ue_get_python_wrapper(u_class->GetSuperClass());

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

PyObject *py_ue_get_outer(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UObject *outer = self->ue_object->GetOuter();

if (!outer)

Py_RETURN_NONE;

ue_PyUObject *ret = ue_get_python_wrapper(outer);

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

PyObject *py_ue_get_outermost(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UObject *outermost = self->ue_object->GetOutermost();

if (!outermost)

Py_RETURN_NONE;

ue_PyUObject *ret = ue_get_python_wrapper(outermost);

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

PyObject *py_ue_conditional_begin_destroy(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

self->ue_object->ConditionalBeginDestroy();

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_ue_is_valid(ue_PyUObject * self, PyObject * args)

{

if (!self->ue_object || !self->ue_object->IsValidLowLevel() || self->ue_object->IsPendingKillOrUnreachable())

{

Py_RETURN_FALSE;

}

Py_RETURN_TRUE;

}

PyObject *py_ue_is_a(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

PyObject *obj;

if (!PyArg_ParseTuple(args, "O:is_a", &obj))

{

return NULL;

}

if (!ue_is_pyuobject(obj))

{

return PyErr_Format(PyExc_Exception, "argument is not a UObject");

}

ue_PyUObject *py_obj = (ue_PyUObject *)obj;

if (self->ue_object->IsA((UClass *)py_obj->ue_object))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_is_child_of(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

PyObject *obj;

if (!PyArg_ParseTuple(args, "O:is_child_of", &obj))

{

return NULL;

}

if (!self->ue_object->IsA<UClass>())

return PyErr_Format(PyExc_Exception, "object is not a UClass");

if (!ue_is_pyuobject(obj))

{

return PyErr_Format(PyExc_Exception, "argument is not a UObject");

}

ue_PyUObject *py_obj = (ue_PyUObject *)obj;

if (!py_obj->ue_object->IsA<UClass>())

return PyErr_Format(PyExc_Exception, "argument is not a UClass");

UClass *parent = (UClass *)py_obj->ue_object;

UClass *child = (UClass *)self->ue_object;

if (child->IsChildOf(parent))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

PyObject *py_ue_post_edit_change(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object)

{

return PyErr_Format(PyExc_Exception, "uobject is not valid");

}

#if WITH_EDITOR

self->ue_object->PostEditChange();

#endif

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_ue_modify(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object)

{

return PyErr_Format(PyExc_Exception, "uobject is not valid");

}

#if WITH_EDITOR

self->ue_object->Modify();

#endif

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_ue_pre_edit_change(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object)

{

return PyErr_Format(PyExc_Exception, "uobject is not valid");

}

#if WITH_EDITOR

self->ue_object->PreEditChange(nullptr);

#endif

Py_INCREF(Py_None);

return Py_None;

}

#if WITH_EDITOR

PyObject *py_ue_set_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

char *metadata_value;

if (!PyArg_ParseTuple(args, "ss:set_metadata", &metadata_key, &metadata_value))

{

return NULL;

}

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

u_class->SetMetaData(FName(UTF8_TO_TCHAR(metadata_key)), UTF8_TO_TCHAR(metadata_value));

}

else if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

u_field->SetMetaData(FName(UTF8_TO_TCHAR(metadata_key)), UTF8_TO_TCHAR(metadata_value));

}

else

{

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_ue_get_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

if (!PyArg_ParseTuple(args, "s:get_metadata", &metadata_key))

{

return NULL;

}

char *metadata_value = nullptr;

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

FString value = u_class->GetMetaData(FName(UTF8_TO_TCHAR(metadata_key)));

return PyUnicode_FromString(TCHAR_TO_UTF8(*value));

}

if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

FString value = u_field->GetMetaData(FName(UTF8_TO_TCHAR(metadata_key)));

return PyUnicode_FromString(TCHAR_TO_UTF8(*value));

}

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

PyObject *py_ue_has_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

if (!PyArg_ParseTuple(args, "s:has_metadata", &metadata_key))

{

return NULL;

}

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

if (u_class->HasMetaData(FName(UTF8_TO_TCHAR(metadata_key))))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

if (u_field->HasMetaData(FName(UTF8_TO_TCHAR(metadata_key))))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

#endif

PyObject *py_ue_call_function(ue_PyUObject * self, PyObject * args, PyObject *kwargs)

{

ue_py_check(self);

UFunction *function = nullptr;

if (PyTuple_Size(args) < 1)

{

return PyErr_Format(PyExc_TypeError, "this function requires at least an argument");

}

PyObject *func_id = PyTuple_GetItem(args, 0);

if (PyUnicodeOrString_Check(func_id))

{

function = self->ue_object->FindFunction(FName(UTF8_TO_TCHAR(PyUnicode_AsUTF8(func_id))));

}

if (!function)

return PyErr_Format(PyExc_Exception, "unable to find function");

return py_ue_ufunction_call(function, self->ue_object, args, 1, kwargs);

}

PyObject *py_ue_find_function(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *name;

if (!PyArg_ParseTuple(args, "s:find_function", &name))

{

return NULL;

}

UFunction *function = self->ue_object->FindFunction(FName(UTF8_TO_TCHAR(name)));

if (!function)

{

Py_INCREF(Py_None);

return Py_None;

}

ue_PyUObject *ret = ue_get_python_wrapper((UObject *)function);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

#if ENGINE_MINOR_VERSION >= 15

PyObject *py_ue_can_modify(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (self->ue_object->CanModify())

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

#endif

PyObject *py_ue_set_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *name;

if (!PyArg_ParseTuple(args, "s:set_name", &name))

{

return NULL;

}

if (!self->ue_object->Rename(UTF8_TO_TCHAR(name), self->ue_object->GetOutermost(), REN_Test))

{

return PyErr_Format(PyExc_Exception, "cannot set name %s", name);

}

if (self->ue_object->Rename(UTF8_TO_TCHAR(name)))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_set_outer(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

PyObject *py_outer;

if (!PyArg_ParseTuple(args, "O:set_outer", &py_outer))

{

return nullptr;

}

UPackage *package = ue_py_check_type<UPackage>(py_outer);

if (!package)

return PyErr_Format(PyExc_Exception, "argument is not a UPackage");

if (!self->ue_object->Rename(nullptr, package, REN_Test))

{

return PyErr_Format(PyExc_Exception, "cannot move to package %s", TCHAR_TO_UTF8(*package->GetPathName()));

}

if (self->ue_object->Rename(nullptr, package))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_get_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetName())));

}

PyObject *py_ue_get_display_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

#if WITH_EDITOR

if (AActor *actor = ue_py_check_type<AActor>(self))

{

return PyUnicode_FromString(TCHAR_TO_UTF8(*actor->GetActorLabel()));

}

#endif

if (UActorComponent *component = ue_py_check_type<UActorComponent>(self))

{

return PyUnicode_FromString(TCHAR_TO_UTF8(*component->GetReadableName()));

}

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetName())));

}

PyObject *py_ue_get_full_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetFullName())));

}

PyObject *py_ue_get_path_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetPathName())));

}

PyObject *py_ue_save_config(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

self->ue_object->SaveConfig();

Py_RETURN_NONE;

}

PyObject *py_ue_set_property(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

PyObject *property_value;

if (!PyArg_ParseTuple(args, "sO:set_property", &property_name, &property_value))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

if (!ue_py_convert_pyobject(property_value, u_property, (uint8 *)self->ue_object))

{

return PyErr_Format(PyExc_Exception, "unable to set property %s", property_name);

}

Py_RETURN_NONE;

}

PyObject *py_ue_set_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

uint64 flags;

if (!PyArg_ParseTuple(args, "sK:set_property_flags", &property_name, &flags))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

u_property->SetPropertyFlags(flags);

Py_RETURN_NONE;

}

PyObject *py_ue_add_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

uint64 flags;

if (!PyArg_ParseTuple(args, "sK:add_property_flags", &property_name, &flags))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

u_property->SetPropertyFlags(u_property->GetPropertyFlags() | flags);

Py_RETURN_NONE;

}

PyObject *py_ue_get_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

if (!PyArg_ParseTuple(args, "s:get_property_flags", &property_name))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

return PyLong_FromUnsignedLong(u_property->GetPropertyFlags());

}

PyObject *py_ue_enum_values(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UEnum *u_enum = (UEnum *)self->ue_object;

uint8 max_enum_value = u_enum->GetMaxEnumValue();

PyObject *ret = PyList_New(0);

for (uint8 i = 0; i < max_enum_value; i++)

{

PyObject *py_long = PyLong_FromLong(i);

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

PyObject *py_ue_enum_names(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UEnum *u_enum = (UEnum *)self->ue_object;

uint8 max_enum_value = u_enum->GetMaxEnumValue();

PyObject *ret = PyList_New(0);

for (uint8 i = 0; i < max_enum_value; i++)

{

#if ENGINE_MINOR_VERSION > 15

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*u_enum->GetNameStringByIndex(i)));

#else

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*u_enum->GetEnumName(i)));

#endif

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

#if ENGINE_MINOR_VERSION >= 15

PyObject *py_ue_enum_user_defined_names(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UUserDefinedEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UUserDefinedEnum *u_enum = (UUserDefinedEnum *)self->ue_object;

TArray<FText> user_defined_names;

u_enum->DisplayNameMap.GenerateValueArray(user_defined_names);

PyObject *ret = PyList_New(0);

for (FText text : user_defined_names)

{

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*text.ToString()));

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

#endif

PyObject *py_ue_properties(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

PyObject *ret = PyList_New(0);

for (TFieldIterator<UProperty> PropIt(u_struct); PropIt; ++PropIt)

{

UProperty* property = *PropIt;

PyObject *property_name = PyUnicode_FromString(TCHAR_TO_UTF8(*property->GetName()));

PyList_Append(ret, property_name);

Py_DECREF(property_name);

}

return ret;

}

PyObject *py_ue_functions(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

PyObject *ret = PyList_New(0);

for (TFieldIterator<UFunction> FuncIt(u_struct); FuncIt; ++FuncIt)

{

UFunction* func = *FuncIt;

PyObject *func_name = PyUnicode_FromString(TCHAR_TO_UTF8(*func->GetFName().ToString()));

PyList_Append(ret, func_name);

Py_DECREF(func_name);

}

return ret;

}

PyObject *py_ue_call(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *call_args;

if (!PyArg_ParseTuple(args, "s:call", &call_args))

{

return NULL;

}

FOutputDeviceNull od_null;

if (!self->ue_object->CallFunctionByNameWithArguments(UTF8_TO_TCHAR(call_args), od_null, NULL, true))

{

return PyErr_Format(PyExc_Exception, "error while calling \"%s\"", call_args);

}

Py_RETURN_NONE;

}

PyObject *py_ue_broadcast(ue_PyUObject *self, PyObject *args)

{

ue_py_check(self);

char *property_name;

if (!PyArg_ParseTuple(args, "s:broadcast", &property_name))

{

return NULL;

}

UProperty *u_property = self->ue_object->GetClass()->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find event property %s", property_name);

if (auto casted_prop = Cast<UMulticastDelegateProperty>(u_property))

{

FMulticastScriptDelegate multiscript_delegate = casted_prop->GetPropertyValue_InContainer(self->ue_object);

uint8 *parms = (uint8 *)FMemory_Alloca(casted_prop->SignatureFunction->PropertiesSize);

FMemory::Memzero(parms, casted_prop->SignatureFunction->PropertiesSize);

multiscript_delegate.ProcessMulticastDelegate<UObject>(parms);

}

else

{

return PyErr_Format(PyExc_Exception, "property is not a UMulticastDelegateProperty");

}

Py_RETURN_NONE;

}

PyObject *py_ue_get_property(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

if (!PyArg_ParseTuple(args, "s:get_property", &property_name))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

return ue_py_convert_property(u_property, (uint8 *)self->ue_object);

}

#if WITH_EDITOR

PyObject *py_ue_get_thumbnail(ue_PyUObject *self, PyObject * args)

{

PyObject *py_generate = nullptr;

if (!PyArg_ParseTuple(args, "|O:get_thumbnail", &py_generate))

{

return nullptr;

}

ue_py_check(self);

TArray<FName> names;

names.Add(FName(*self->ue_object->GetFullName()));

FThumbnailMap thumb_map;

FObjectThumbnail *object_thumbnail = nullptr;

if (!ThumbnailTools::ConditionallyLoadThumbnailsForObjects(names, thumb_map))

{

if (py_generate && PyObject_IsTrue(py_generate))

{

object_thumbnail = ThumbnailTools::GenerateThumbnailForObjectToSaveToDisk(self->ue_object);

}

}

else

{

object_thumbnail = &thumb_map[names[0]];

}

if (!object_thumbnail)

{

return PyErr_Format(PyExc_Exception, "unable to retrieve thumbnail");

}

return py_ue_new_fobject_thumbnail(*object_thumbnail);

}

PyObject *py_ue_render_thumbnail(ue_PyUObject *self, PyObject * args)

{

int width = ThumbnailTools::DefaultThumbnailSize;

int height = ThumbnailTools::DefaultThumbnailSize;

PyObject *no_flush = nullptr;

if (!PyArg_ParseTuple(args, "|iiO:render_thumbnail", &width, height, &no_flush))

{

return nullptr;

}

ue_py_check(self);

FObjectThumbnail object_thumbnail;

ThumbnailTools::RenderThumbnail(self->ue_object, width, height,

(no_flush && PyObject_IsTrue(no_flush)) ? ThumbnailTools::EThumbnailTextureFlushMode::NeverFlush : ThumbnailTools::EThumbnailTextureFlushMode::AlwaysFlush,

nullptr, &object_thumbnail);

return py_ue_new_fobject_thumbnail(object_thumbnail);

}

#endif

PyObject *py_ue_get_uproperty(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;