#include "UEPyEditor.h"

#if WITH_EDITOR

#include "Developer/AssetTools/Public/AssetToolsModule.h"

#include "Editor/UnrealEd/Classes/Factories/Factory.h"

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

#include "Kismet2/KismetEditorUtilities.h"

#include "Editor/ContentBrowser/Public/ContentBrowserModule.h"

#include "Editor/UnrealEd/Public/PackageTools.h"

#include "UnrealEd.h"

#include "FbxMeshUtils.h"

#include "Kismet2/BlueprintEditorUtils.h"

#include "Editor/LevelEditor/Public/LevelEditorActions.h"

#include "Editor/UnrealEd/Public/EditorLevelUtils.h"

#include "Runtime/Projects/Public/Interfaces/IPluginManager.h"

#include "ObjectTools.h"

#include "Developer/AssetTools/Public/IAssetTools.h"

#include "Editor/ContentBrowser/Public/IContentBrowserSingleton.h"

#include "Runtime/Engine/Classes/EdGraph/EdGraphPin.h"

#include "Runtime/Engine/Classes/EdGraph/EdGraphSchema.h"

#include "Toolkits/AssetEditorManager.h"

#include "LevelEditor.h"

#include "Editor/LandscapeEditor/Public/LandscapeEditorUtils.h"

#include "Editor/LandscapeEditor/Public/LandscapeEditorModule.h"

#include "Editor/LandscapeEditor/Public/LandscapeFileFormatInterface.h"

#include "Developer/Settings/Public/ISettingsModule.h"

#include "Engine/Blueprint.h"

#include "Wrappers/UEPyFARFilter.h"

#include "Wrappers/UEPyFVector.h"

#include "Wrappers/UEPyFAssetData.h"

#include "Wrappers/UEPyFEditorViewportClient.h"

#include "Wrappers/UEPyIAssetEditorInstance.h"

#include "Editor/MainFrame/Public/Interfaces/IMainFrameModule.h"

#include "Runtime/Core/Public/HAL/ThreadHeartBeat.h"

#include "Runtime/Engine/Public/EditorSupportDelegates.h"

#include "UEPyIPlugin.h"

PyObject *py_unreal_engine_redraw_all_viewports(PyObject * self, PyObject * args)

{

FEditorSupportDelegates::RedrawAllViewports.Broadcast();

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_update_ui(PyObject * self, PyObject * args)

{

FEditorSupportDelegates::UpdateUI.Broadcast();

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_play_in_viewport(PyObject * self, PyObject * args)

{

PyObject *py_vector = nullptr;

PyObject *py_rotator = nullptr;

if (!PyArg_ParseTuple(args, "|OO:editor_play_in_viewport", &py_vector, &py_rotator))

{

return NULL;

}

FVector v;

FRotator r;

if (py_vector)

{

ue_PyFVector *vector = py_ue_is_fvector(py_vector);

if (!vector)

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

v = vector->vec;

}

if (py_rotator)

{

ue_PyFRotator *rotator = py_ue_is_frotator(py_rotator);

if (!rotator)

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

r = rotator->rot;

}

FLevelEditorModule &EditorModule = FModuleManager::LoadModuleChecked<FLevelEditorModule>("LevelEditor");

if (!EditorModule.GetFirstActiveViewport().IsValid())

return PyErr_Format(PyExc_Exception, "no active LevelEditor Viewport");

Py_BEGIN_ALLOW_THREADS;

GEditor->RequestPlaySession(py_vector == nullptr, EditorModule.GetFirstActiveViewport(), true, &v, &r);

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_request_play_session(PyObject * self, PyObject * args)

{

PyObject *py_at_player_start = nullptr;

PyObject *py_simulate_in_editor = nullptr;

if (!PyArg_ParseTuple(args, "|OO:request_play_session", &py_at_player_start, &py_simulate_in_editor))

{

return nullptr;

}

bool bAtPlayerStart = py_at_player_start && PyObject_IsTrue(py_at_player_start);

bool bSimulate = py_simulate_in_editor && PyObject_IsTrue(py_simulate_in_editor);

Py_BEGIN_ALLOW_THREADS;

GEditor->RequestPlaySession(bAtPlayerStart, nullptr, bSimulate);

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_get_editor_world(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

UWorld *world = GEditor->GetEditorWorldContext().World();

Py_RETURN_UOBJECT(world);

}

PyObject *py_unreal_engine_console_exec(PyObject * self, PyObject * args)

{

char *command;

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

if (!PyArg_ParseTuple(args, "s:console_exec", &command))

{

return NULL;

}

Py_BEGIN_ALLOW_THREADS;

GEditor->Exec(GEditor->GetEditorWorldContext().World(), UTF8_TO_TCHAR(command), *GLog);

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_allow_actor_script_execution_in_editor(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

PyObject *obj = nullptr;

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

{

return NULL;

}

bool enable = false;

if (PyObject_IsTrue(obj))

enable = true;

GAllowActorScriptExecutionInEditor = enable;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_get_selected_actors(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

PyObject *actors = PyList_New(0);

USelection *selection = GEditor->GetSelectedActors();

int32 nums = selection->CountSelections<UObject>();

for (int32 i = 0; i < nums; i++)

{

UObject *obj = selection->GetSelectedObject(i);

if (!obj->IsA<AActor>())

continue;

AActor *actor = (AActor *)obj;

ue_PyUObject *item = ue_get_python_uobject(actor);

if (item)

PyList_Append(actors, (PyObject *)item);

}

return actors;

}

PyObject *py_unreal_engine_editor_command_build(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

Py_BEGIN_ALLOW_THREADS;

FLevelEditorActionCallbacks::Build_Execute();

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_command_save_current_level(PyObject * self, PyObject * args)

{

Py_BEGIN_ALLOW_THREADS;

FLevelEditorActionCallbacks::Save();

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_command_save_all_levels(PyObject * self, PyObject * args)

{

Py_BEGIN_ALLOW_THREADS;

FLevelEditorActionCallbacks::SaveAllLevels();

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_save_all(PyObject * self, PyObject * args)

{

Py_BEGIN_ALLOW_THREADS;

FEditorFileUtils::SaveDirtyPackages(false, true, true, false, false, false);

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_command_build_lighting(PyObject * self, PyObject * args)

{

Py_BEGIN_ALLOW_THREADS;

FLevelEditorActionCallbacks::BuildLightingOnly_Execute();

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_deselect_actors(PyObject * self, PyObject * args)

{

GEditor->SelectNone(true, true, false);

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_play(PyObject * self, PyObject * args)

{

PyObject *py_vector = nullptr;

PyObject *py_rotator = nullptr;

if (!PyArg_ParseTuple(args, "|OO:editor_play", &py_vector, &py_rotator))

{

return NULL;

}

FVector v;

FRotator r;

if (py_vector)

{

ue_PyFVector *vector = py_ue_is_fvector(py_vector);

if (!vector)

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

v = vector->vec;

}

if (py_rotator)

{

ue_PyFRotator *rotator = py_ue_is_frotator(py_rotator);

if (!rotator)

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

r = rotator->rot;

}

Py_BEGIN_ALLOW_THREADS;

#if ENGINE_MINOR_VERSION >= 17

const FString mobile_device = FString("");

GEditor->RequestPlaySession(&v, &r, false, false, mobile_device);

#else

GEditor->RequestPlaySession(&v, &r, false, false);

#endif

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_select_actor(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

PyObject *obj;

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

{

return nullptr;

}

AActor *actor = ue_py_check_type<AActor>(obj);

if (!actor)

return PyErr_Format(PyExc_Exception, "uobject is not an Actor");

GEditor->SelectActor(actor, true, true);

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_import_asset(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

//char *filename;

PyObject * assetsObject = nullptr;

char *destination;

PyObject *obj = nullptr;

PyObject *py_sync = nullptr;

if (!PyArg_ParseTuple(args, "Os|OO:import_asset", &assetsObject, &destination, &obj, &py_sync))

{

return nullptr;

}

FString Result;

// avoid crash on wrong path

if (!FPackageName::TryConvertLongPackageNameToFilename(UTF8_TO_TCHAR(destination), Result, ""))

{

return PyErr_Format(PyExc_Exception, "invalid asset root path");

}

UClass *factory_class = nullptr;

UFactory *factory = nullptr;

bool sync_to_browser = false;

if (!obj || obj == Py_None)

{

factory_class = nullptr;

}

else if (ue_is_pyuobject(obj))

{

ue_PyUObject *py_factory = (ue_PyUObject *)obj;

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

{

factory_class = (UClass *)py_factory->ue_object;

}

else if (py_factory->ue_object->IsA<UFactory>())

{

factory = (UFactory *)py_factory->ue_object;

}

else

{

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

}

}

else if (PyUnicodeOrString_Check(obj))

{

const char *class_name = UEPyUnicode_AsUTF8(obj);

UClass *u_class = FindObject<UClass>(ANY_PACKAGE, UTF8_TO_TCHAR(class_name));

if (u_class)

{

ue_PyUObject *py_obj = ue_get_python_uobject(u_class);

if (!py_obj)

{

return PyErr_Format(PyExc_Exception, "invalid uobject");

}

factory_class = (UClass *)py_obj->ue_object;

}

}

else

{

return PyErr_Format(PyExc_Exception, "invalid uobject");

}

if (factory_class)

{

factory = NewObject<UFactory>(GetTransientPackage(), factory_class);

if (!factory)

{

return PyErr_Format(PyExc_Exception, "unable to create factory");

}

}

TArray<FString> files;

if (PyList_Check(assetsObject))

{

// parse the list object

int numLines = PyList_Size(assetsObject);

if (numLines <= 0)

{

return PyErr_Format(PyExc_Exception, "Asset paths is not a valid list");

}

for (int i = 0; i < numLines; ++i)

{

PyObject * strObj = PyList_GetItem(assetsObject, i);

#if PY_MAJOR_VERSION >= 3

char * filename = PyBytes_AS_STRING(PyUnicode_AsEncodedString(strObj, "utf-8", "Error"));

#else

char * filename = PyString_AsString(PyObject_Str(strObj));

#endif

files.Add(UTF8_TO_TCHAR(filename));

}

}

else if (PyUnicodeOrString_Check(assetsObject))

{

#if PY_MAJOR_VERSION >= 3

char * filename = PyBytes_AS_STRING(PyUnicode_AsEncodedString(assetsObject, "utf-8", "Error"));

#else

char * filename = PyString_AsString(PyObject_Str(assetsObject));

#endif

files.Add(UTF8_TO_TCHAR(filename));

}

else

{

return PyErr_Format(PyExc_Exception, "Not a string nor valid list of string");

}

if (py_sync && PyObject_IsTrue(py_sync))

{

sync_to_browser = true;

}

TArray<UObject *> objects;

Py_BEGIN_ALLOW_THREADS;

FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");

objects = AssetToolsModule.Get().ImportAssets(files, UTF8_TO_TCHAR(destination), factory, sync_to_browser);

Py_END_ALLOW_THREADS;

if (objects.Num() == 1)

{

UObject *object = objects[0];

Py_RETURN_UOBJECT(object);

}

else if (objects.Num() > 1)

{

PyObject *assets_list = PyList_New(0);

for (UObject *object : objects)

{

ue_PyUObject *ret = ue_get_python_uobject(object);

if (!ret)

{

Py_DECREF(assets_list);

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

}

PyList_Append(assets_list, (PyObject *)ret);

}

return assets_list;

}

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_editor_tick(PyObject * self, PyObject * args)

{

float delta_seconds = FApp::GetDeltaTime();

PyObject *py_idle = nullptr;

if (!PyArg_ParseTuple(args, "|fO:editor_tick", &delta_seconds, &py_idle))

{

return NULL;

}

bool bIdle = false;

if (py_idle && PyObject_IsTrue(py_idle))

bIdle = true;

Py_BEGIN_ALLOW_THREADS;

GEditor->Tick(delta_seconds, bIdle);

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_message_dialog_open(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

int app_msg_type;

char *text;

if (!PyArg_ParseTuple(args, "is:message_dialog_open", &app_msg_type, &text))

{

return nullptr;

}

EAppReturnType::Type ret;

Py_BEGIN_ALLOW_THREADS;

ret = FMessageDialog::Open((EAppMsgType::Type) app_msg_type, FText::FromString(UTF8_TO_TCHAR(text)));

Py_END_ALLOW_THREADS;

return PyLong_FromLong(ret);

}

PyObject *py_unreal_engine_create_modal_save_asset_dialog(PyObject * self, PyObject * args)

{

char *title = (char *)"";

char *path = (char*)"";

char *default_name = (char*)"";

if (!PyArg_ParseTuple(args, "|sss:create_modal_save_asset_dialog", &title, &path, &default_name))

{

return nullptr;

}

FString ret;

Py_BEGIN_ALLOW_THREADS;

FSaveAssetDialogConfig config;

config.DialogTitleOverride = FText::FromString(FString(UTF8_TO_TCHAR(title)));

config.DefaultPath = FString(UTF8_TO_TCHAR(path));

config.DefaultAssetName = FString(UTF8_TO_TCHAR(default_name));

config.ExistingAssetPolicy = ESaveAssetDialogExistingAssetPolicy::AllowButWarn;

FContentBrowserModule &ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");

ret = ContentBrowserModule.Get().CreateModalSaveAssetDialog(config);

Py_END_ALLOW_THREADS;

if (ret.IsEmpty())

{

Py_RETURN_NONE;

}

return PyUnicode_FromString(TCHAR_TO_UTF8(*ret));

}

PyObject *py_unreal_engine_get_asset(PyObject * self, PyObject * args)

{

char *path;

if (!PyArg_ParseTuple(args, "s:get_asset", &path))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

FAssetData asset = AssetRegistryModule.Get().GetAssetByObjectPath(UTF8_TO_TCHAR(path));

if (!asset.IsValid())

return PyErr_Format(PyExc_Exception, "unable to find asset %s", path);

Py_RETURN_UOBJECT(asset.GetAsset());

}

PyObject *py_unreal_engine_is_loading_assets(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

if (AssetRegistryModule.Get().IsLoadingAssets())

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

PyObject *py_unreal_engine_wait_for_assets(PyObject * self, PyObject * args)

{

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

while (AssetRegistryModule.Get().IsLoadingAssets())

{

Py_BEGIN_ALLOW_THREADS;

AssetRegistryModule.Get().Tick(-1.0f);

FThreadHeartBeat::Get().HeartBeat();

FPlatformProcess::SleepNoStats(0.0001f);

Py_END_ALLOW_THREADS;

}

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_find_asset(PyObject * self, PyObject * args)

{

char *path;

if (!PyArg_ParseTuple(args, "s:find_asset", &path))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

FAssetData asset = AssetRegistryModule.Get().GetAssetByObjectPath(UTF8_TO_TCHAR(path));

if (!asset.IsValid())

{

Py_RETURN_NONE;

}

Py_RETURN_UOBJECT(asset.GetAsset());

}

PyObject *py_unreal_engine_create_asset(PyObject * self, PyObject * args)

{

char *asset_name;

char *package_path;

PyObject *py_class;

PyObject *py_factory;

if (!PyArg_ParseTuple(args, "ssOO:create_asset", &asset_name, &package_path, &py_class, &py_factory))

{

return nullptr;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

UClass *uclass = ue_py_check_type<UClass>(py_class);

if (!uclass)

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

UFactory *factory = ue_py_check_type<UFactory>(py_factory);

if (!factory)

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

FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");

UObject *uobject = AssetToolsModule.Get().CreateAsset(FString(UTF8_TO_TCHAR(asset_name)), FString(UTF8_TO_TCHAR(package_path)), uclass, factory);

if (!uobject)

return PyErr_Format(PyExc_Exception, "unable to create asset");

Py_RETURN_UOBJECT(uobject);

}

PyObject *py_unreal_engine_get_asset_referencers(PyObject * self, PyObject * args)

{

char *path;

int depency_type = (int)EAssetRegistryDependencyType::All;

if (!PyArg_ParseTuple(args, "s|i:get_asset_referencers", &path, &depency_type))

{

return nullptr;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

TArray<FName> referencers;

AssetRegistryModule.Get().GetReferencers(UTF8_TO_TCHAR(path), referencers, (EAssetRegistryDependencyType::Type) depency_type);

PyObject *referencers_list = PyList_New(0);

for (FName name : referencers)

{

PyList_Append(referencers_list, PyUnicode_FromString(TCHAR_TO_UTF8(*name.ToString())));

}

return referencers_list;

}

PyObject *py_unreal_engine_get_asset_identifier_referencers(PyObject * self, PyObject * args)

{

char *path;

int depency_type = (int)EAssetRegistryDependencyType::All;

if (!PyArg_ParseTuple(args, "s|i:get_asset_identifier_referencers", &path, &depency_type))

{

return nullptr;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

TArray<FAssetIdentifier> referencers;

AssetRegistryModule.Get().GetReferencers(FAssetIdentifier::FromString(UTF8_TO_TCHAR(path)), referencers, (EAssetRegistryDependencyType::Type) depency_type);

PyObject *referencers_list = PyList_New(0);

for (FAssetIdentifier identifier : referencers)

{

PyList_Append(referencers_list, PyUnicode_FromString(TCHAR_TO_UTF8(*identifier.ToString())));

}

return referencers_list;

}

PyObject *py_unreal_engine_get_asset_dependencies(PyObject * self, PyObject * args)

{

char *path;

int depency_type = (int)EAssetRegistryDependencyType::All;

if (!PyArg_ParseTuple(args, "s|i:get_asset_dependencies", &path, &depency_type))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

TArray<FName> dependencies;

AssetRegistryModule.Get().GetDependencies(UTF8_TO_TCHAR(path), dependencies, (EAssetRegistryDependencyType::Type) depency_type);

PyObject *dependencies_list = PyList_New(0);

for (FName name : dependencies)

{

PyList_Append(dependencies_list, PyUnicode_FromString(TCHAR_TO_UTF8(*name.ToString())));

}

return dependencies_list;

}

PyObject *py_unreal_engine_get_long_package_path(PyObject * self, PyObject * args)

{

char *path;

if (!PyArg_ParseTuple(args, "s:get_long_package_path", &path))

{

return NULL;

}

const FString package_path = FPackageName::GetLongPackagePath(UTF8_TO_TCHAR(path));

return PyUnicode_FromString(TCHAR_TO_UTF8(*(package_path)));

}

PyObject *py_unreal_engine_get_long_package_asset_name(PyObject * self, PyObject * args)

{

char *path;

if (!PyArg_ParseTuple(args, "s:get_long_package_asset_name", &path))

{

return NULL;

}

const FString asset_name = FPackageName::GetLongPackageAssetName(UTF8_TO_TCHAR(path));

return PyUnicode_FromString(TCHAR_TO_UTF8(*(asset_name)));

}

PyObject *py_unreal_engine_rename_asset(PyObject * self, PyObject * args)

{

char *path;

char *destination;

PyObject *py_only_soft = nullptr;

if (!PyArg_ParseTuple(args, "ss|O:rename_asset", &path, &destination, &py_only_soft))

{

return nullptr;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

FAssetData asset = AssetRegistryModule.Get().GetAssetByObjectPath(UTF8_TO_TCHAR(path));

if (!asset.IsValid())

return PyErr_Format(PyExc_Exception, "unable to find asset %s", path);

FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");

TArray<FAssetRenameData> AssetsAndNames;

FString Destination = FString(UTF8_TO_TCHAR(destination));

#if ENGINE_MINOR_VERSION > 17

FAssetRenameData RenameData;

RenameData.Asset = asset.GetAsset();

if (Destination.StartsWith("/"))

{

RenameData.NewPackagePath = FPackageName::GetLongPackagePath(Destination);

RenameData.NewName = FPackageName::GetShortName(Destination);

}

else

{

RenameData.NewPackagePath = FPackageName::GetLongPackagePath(UTF8_TO_TCHAR(path));

RenameData.NewName = Destination;

}

if (py_only_soft && PyObject_IsTrue(py_only_soft))

{

RenameData.bOnlyFixSoftReferences = true;

}

#else

FAssetRenameData RenameData(TWeakObjectPtr<UObject>(asset.GetAsset()), FPackageName::GetLongPackagePath(UTF8_TO_TCHAR(path)), Destination.StartsWith("/") ? FPackageName::GetShortName(Destination) : Destination);

#endif

AssetsAndNames.Add(RenameData);

#if ENGINE_MINOR_VERSION < 19

AssetToolsModule.Get().RenameAssets(AssetsAndNames);

#else

if (!AssetToolsModule.Get().RenameAssets(AssetsAndNames))

{

return PyErr_Format(PyExc_Exception, "unable to rename asset %s", path);

}

#endif

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_duplicate_asset(PyObject * self, PyObject * args)

{

char *path;

char *package_name;

char *object_name;

if (!PyArg_ParseTuple(args, "sss:duplicate_asset", &path, &package_name, &object_name))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

FAssetData asset = AssetRegistryModule.Get().GetAssetByObjectPath(UTF8_TO_TCHAR(path));

if (!asset.IsValid())

return PyErr_Format(PyExc_Exception, "unable to find asset %s", path);

UObject *u_object = asset.GetAsset();

ObjectTools::FPackageGroupName pgn;

pgn.ObjectName = UTF8_TO_TCHAR(object_name);

pgn.GroupName = FString("");

pgn.PackageName = UTF8_TO_TCHAR(package_name);

TSet<UPackage *> refused_packages;

FText error_text;

#if ENGINE_MINOR_VERSION < 14

UObject *new_asset = ObjectTools::DuplicateSingleObject(u_object, pgn, refused_packages);

#else

UObject *new_asset = ObjectTools::DuplicateSingleObject(u_object, pgn, refused_packages, false);

#endif

if (!new_asset)

{

return PyErr_Format(PyExc_Exception, "unable to duplicate asset %s", path);

}

FAssetRegistryModule::AssetCreated(new_asset);

Py_RETURN_UOBJECT(new_asset);

}

PyObject *py_unreal_engine_delete_asset(PyObject * self, PyObject * args)

{

char *path;

PyObject *py_show_confirmation = nullptr;

if (!PyArg_ParseTuple(args, "s|O:delete_asset", &path, &py_show_confirmation))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

bool show_confirmation = false;

if (py_show_confirmation && PyObject_IsTrue(py_show_confirmation))

{

show_confirmation = true;

}

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

FAssetData asset = AssetRegistryModule.Get().GetAssetByObjectPath(UTF8_TO_TCHAR(path));

if (!asset.IsValid())

return PyErr_Format(PyExc_Exception, "unable to find asset %s", path);

UObject *u_object = asset.GetAsset();

TArray<UObject *> objects;

objects.Add(u_object);

if (ObjectTools::DeleteObjects(objects, show_confirmation) < 1)

{

if (ObjectTools::ForceDeleteObjects(objects, show_confirmation) < 1)

{

return PyErr_Format(PyExc_Exception, "unable to delete asset %s", path);

}

}

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_delete_object(PyObject * self, PyObject * args)

{

PyObject *py_obj;

PyObject *py_bool = nullptr;

if (!PyArg_ParseTuple(args, "O|O:delete_object", &py_obj, &py_bool))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

UObject *u_object = ue_py_check_type<UObject>(py_obj);

if (!u_object)

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

TArray<UObject *> objects_to_delete;

objects_to_delete.Add(u_object);

if (py_bool && PyObject_IsTrue(py_bool))

{

if (ObjectTools::ForceDeleteObjects(objects_to_delete, false) < 1)

{

return PyErr_Format(PyExc_Exception, "unable to delete object");

}

}

else

{

if (ObjectTools::DeleteObjects(objects_to_delete, false) < 1)

{

return PyErr_Format(PyExc_Exception, "unable to delete asset");

}

}

Py_RETURN_NONE;

}

PyObject *py_unreal_engine_get_assets(PyObject * self, PyObject * args)

{

char *path;

PyObject *py_recursive = nullptr;

if (!PyArg_ParseTuple(args, "s|O:get_assets", &path, &py_recursive))

{

return NULL;

}

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

bool recursive = false;

if (py_recursive && PyObject_IsTrue(py_recursive))

recursive = true;

TArray<FAssetData> assets;

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

AssetRegistryModule.Get().GetAssetsByPath(UTF8_TO_TCHAR(path), assets, recursive);

PyObject *assets_list = PyList_New(0);

for (FAssetData asset : assets)

{

if (!asset.IsValid())

continue;

ue_PyUObject *ret = ue_get_python_uobject(asset.GetAsset());

if (ret)

{

PyList_Append(assets_list, (PyObject *)ret);

}

}

return assets_list;

}

PyObject *py_unreal_engine_get_assets_by_filter(PyObject * self, PyObject * args, PyObject *kwargs)

{

PyObject *pyfilter;

PyObject *py_return_asset_data = nullptr;

static char *kw_names[] = { (char *)"filter", (char *)"return_asset_data", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:get_assets_by_filter", kw_names, &pyfilter, &py_return_asset_data))

{

return nullptr;

}

ue_PyFARFilter *py_filter = py_ue_is_farfilter(pyfilter);

if (!py_filter)

return PyErr_Format(PyExc_Exception, "Arg is not a FARFilter");

FARFilter& Filter = py_filter->filter;

py_ue_sync_farfilter((PyObject *)py_filter);

TArray<FAssetData> assets;

Py_BEGIN_ALLOW_THREADS;

FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>("AssetRegistry");

AssetRegistryModule.Get().SearchAllAssets(true);

AssetRegistryModule.Get().GetAssets(Filter, assets);

Py_END_ALLOW_THREADS;

bool return_asset_data = false;

if (py_return_asset_data && PyObject_IsTrue(py_return_asset_data))

return_asset_data = true;

PyObject *assets_list = PyList_New(0);

for (FAssetData asset : assets)

{

if (!asset.IsValid())

continue;

PyObject *ret = nullptr;

if (return_asset_data)

{

ret = py_ue_new_fassetdata(asset);

}