improved capture and asset export

Author: Roberto De Ioris

Source/UnrealEnginePython/Private/UEPyEditor.cpp

@@ -416,7 +416,7 @@ PyObject *py_unreal_engine_import_asset(PyObject * self, PyObject * args)
 		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");
@@ -2334,5 +2334,46 @@ PyObject *py_unreal_engine_editor_sync_browser_to_assets(PyObject * self, PyObje
 
 	Py_RETURN_NONE;
 }
+
+PyObject *py_unreal_engine_export_assets(PyObject * self, PyObject * args)
+{
+
+	if (!GEditor)
+		return PyErr_Format(PyExc_Exception, "no GEditor found");
+
+	PyObject * py_assets = nullptr;
+	char *filename;
+
+	if (!PyArg_ParseTuple(args, "Os:export_assets", &py_assets, &filename))
+	{
+		return nullptr;
+	}
+
+	TArray<UObject *> UObjects;
+	PyObject *py_iter = PyObject_GetIter(py_assets);
+
+	if (!py_iter)
+	{
+		return PyErr_Format(PyExc_Exception, "argument is not an iterable of UObject");
+	}
+
+	while (PyObject *py_item = PyIter_Next(py_iter))
+	{
+		UObject *Object = ue_py_check_type<UObject>(py_item);
+		if (!Object)
+		{
+			Py_DECREF(py_iter);
+			return PyErr_Format(PyExc_Exception, "argument is not an iterable of UObject");
+		}
+		UObjects.Add(Object);
+	}
+
+	Py_DECREF(py_iter);
+
+	FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
+	AssetToolsModule.Get().ExportAssets(UObjects, FString(UTF8_TO_TCHAR(filename)));
+
+	Py_RETURN_NONE;
+}
 #endif
 

Source/UnrealEnginePython/Private/UEPyEditor.h

@@ -120,4 +120,5 @@ PyObject *py_unreal_engine_show_viewer(PyObject *, PyObject *);
 PyObject *py_unreal_engine_unregister_settings(PyObject *, PyObject *);
 
 PyObject *py_unreal_engine_request_play_session(PyObject *, PyObject *);
+PyObject *py_unreal_engine_export_assets(PyObject *, PyObject *);
 #endif

Source/UnrealEnginePython/Private/UEPyModule.cpp

@@ -35,6 +35,7 @@
 #include "UObject/UEPyLandscape.h"
 #include "UObject/UEPyUserDefinedStruct.h"
 #include "UObject/UEPyDataTable.h"
+#include "UObject/UEPyExporter.h"
 
 
 #include "UEPyAssetUserData.h"
@@ -225,6 +226,7 @@ static PyMethodDef unreal_engine_methods[] = {
 	{ "editor_select_actor", py_unreal_engine_editor_select_actor, METH_VARARGS, "" },
 	{ "editor_deselect_actors", py_unreal_engine_editor_deselect_actors, METH_VARARGS, "" },
 	{ "import_asset", py_unreal_engine_import_asset, METH_VARARGS, "" },
+	{ "export_assets", py_unreal_engine_export_assets, METH_VARARGS, "" },
 	{ "get_asset", py_unreal_engine_get_asset, METH_VARARGS, "" },
 	{ "find_asset", py_unreal_engine_find_asset, METH_VARARGS, "" },
 	{ "delete_object", py_unreal_engine_delete_object, METH_VARARGS, "" },
@@ -378,6 +380,8 @@ static PyMethodDef unreal_engine_methods[] = {
 	{ "register_settings", py_unreal_engine_register_settings, METH_VARARGS, "" },
 	{ "show_viewer", py_unreal_engine_show_viewer, METH_VARARGS, "" },
 	{ "unregister_settings", py_unreal_engine_unregister_settings, METH_VARARGS, "" },
+
+	{ "in_editor_capture", py_unreal_engine_in_editor_capture, METH_VARARGS, "" },
 #endif
 
 	{ "clipboard_copy", py_unreal_engine_clipboard_copy, METH_VARARGS, "" },
@@ -546,6 +550,8 @@ static PyMethodDef ue_PyUObject_methods[] = {
 	{ "data_table_get_all_rows", (PyCFunction)py_ue_data_table_get_all_rows, METH_VARARGS, "" },
 #endif
 
+	{ "export_to_file", (PyCFunction)py_ue_export_to_file, METH_VARARGS, "" },
+
 	{ "is_rooted", (PyCFunction)py_ue_is_rooted, METH_VARARGS, "" },
 	{ "add_to_root", (PyCFunction)py_ue_add_to_root, METH_VARARGS, "" },
 	{ "auto_root", (PyCFunction)py_ue_auto_root, METH_VARARGS, "" },
@@ -803,7 +809,6 @@ static PyMethodDef ue_PyUObject_methods[] = {
 	{ "capture_load_from_config", (PyCFunction)py_ue_capture_load_from_config, METH_VARARGS, "" },
 
 #if WITH_EDITOR
-	{ "in_editor_capture", (PyCFunction)py_ue_in_editor_capture, METH_VARARGS, "" },
 	{ "set_level_sequence_asset", (PyCFunction)py_ue_set_level_sequence_asset, METH_VARARGS, "" },
 #endif
 

Source/UnrealEnginePython/Private/UObject/UEPyCapture.cpp

@@ -7,7 +7,8 @@
 /*
 
 This is taken as-is (more or less) from MovieSceneCaptureDialogModule.cpp
-to automate sequencer capturing
+to automate sequencer capturing. The only relevant implementation is the support
+for a queue of UMovieSceneCapture objects
 
 */
 
@@ -16,44 +17,61 @@ to automate sequencer capturing
 #include "Slate/SceneViewport.h"
 #include "AutomatedLevelSequenceCapture.h"
 
-struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
+struct FInEditorMultiCapture : TSharedFromThis<FInEditorMultiCapture>
 {
 
-	static TWeakPtr<FInEditorCapture> CreateInEditorCapture(UMovieSceneCapture* InCaptureObject)
+	static TWeakPtr<FInEditorMultiCapture> CreateInEditorMultiCapture(TArray<UMovieSceneCapture*> InCaptureObjects)
 	{
 		// FInEditorCapture owns itself, so should only be kept alive by itself, or a pinned (=> temporary) weakptr
-		FInEditorCapture* Capture = new FInEditorCapture;
-		Capture->Start(InCaptureObject);
+		FInEditorMultiCapture* Capture = new FInEditorMultiCapture;
+		Capture->CaptureObjects = InCaptureObjects;
+		for (UMovieSceneCapture *SceneCapture : Capture->CaptureObjects)
+		{
+			SceneCapture->AddToRoot();
+		}
+		Capture->Dequeue();
 		return Capture->AsShared();
 	}
 
-	UWorld* GetWorld() const
+private:
+	FInEditorMultiCapture()
 	{
-		return CapturingFromWorld;
+		CapturingFromWorld = nullptr;
 	}
 
-private:
-	FInEditorCapture()
+	void Die()
 	{
-		CapturingFromWorld = nullptr;
-		CaptureObject = nullptr;
+		for (UMovieSceneCapture *SceneCapture : CaptureObjects)
+		{
+			SceneCapture->RemoveFromRoot();
+		}
+		OnlyStrongReference = nullptr;
 	}
 
-	void Start(UMovieSceneCapture* InCaptureObject)
+	void Dequeue()
 	{
-		check(InCaptureObject);
+
+		if (CaptureObjects.Num() < 1)
+		{
+			Die();
+			return;
+		}
+
+		CurrentCaptureObject = CaptureObjects[0];
+
+		check(CurrentCaptureObject);
 
 		CapturingFromWorld = nullptr;
-		OnlyStrongReference = MakeShareable(this);
 
-		CaptureObject = InCaptureObject;
+		if (!OnlyStrongReference.IsValid())
+			OnlyStrongReference = MakeShareable(this);
 
 		ULevelEditorPlaySettings* PlayInEditorSettings = GetMutableDefault<ULevelEditorPlaySettings>();
 
 		bScreenMessagesWereEnabled = GAreScreenMessagesEnabled;
 		GAreScreenMessagesEnabled = false;
 
-		if (!InCaptureObject->Settings.bEnableTextureStreaming)
+		if (!CurrentCaptureObject->Settings.bEnableTextureStreaming)
 		{
 			const int32 UndefinedTexturePoolSize = -1;
 			IConsoleVariable* CVarStreamingPoolSize = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Streaming.PoolSize"));
@@ -71,14 +89,18 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 			}
 		}
 
+		// cleanup from previous run
+		BackedUpPlaySettings.Empty();
+
 		FObjectWriter(PlayInEditorSettings, BackedUpPlaySettings);
+
 		OverridePlaySettings(PlayInEditorSettings);
 
-		CaptureObject->AddToRoot();
-		CaptureObject->OnCaptureFinished().AddRaw(this, &FInEditorCapture::OnEnd);
+		//CurrentCaptureObject->AddToRoot();
+		CurrentCaptureObject->OnCaptureFinished().AddRaw(this, &FInEditorMultiCapture::OnEnd);
 
-		UGameViewportClient::OnViewportCreated().AddRaw(this, &FInEditorCapture::OnStart);
-		FEditorDelegates::EndPIE.AddRaw(this, &FInEditorCapture::OnEndPIE);
+		UGameViewportClient::OnViewportCreated().AddRaw(this, &FInEditorMultiCapture::OnStart);
+		FEditorDelegates::EndPIE.AddRaw(this, &FInEditorMultiCapture::OnEndPIE);
 
 		FAudioDevice* AudioDevice = GEngine->GetMainAudioDevice();
 		if (AudioDevice != nullptr)
@@ -87,12 +109,19 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 			AudioDevice->SetTransientMasterVolume(0.0f);
 		}
 
+		// play at the next tick
+		FTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateRaw(this, &FInEditorMultiCapture::PlaySession), 0);
+	}
+
+	bool PlaySession(float DeltaTime)
+	{
 		GEditor->RequestPlaySession(true, nullptr, false);
+		return false;
 	}
 
 	void OverridePlaySettings(ULevelEditorPlaySettings* PlayInEditorSettings)
 	{
-		const FMovieSceneCaptureSettings& Settings = CaptureObject->GetSettings();
+		const FMovieSceneCaptureSettings& Settings = CurrentCaptureObject->GetSettings();
 
 		PlayInEditorSettings->NewWindowWidth = Settings.Resolution.ResX;
 		PlayInEditorSettings->NewWindowHeight = Settings.Resolution.ResY;
@@ -150,7 +179,7 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 
 					TSharedPtr<SWindow> Window = SlatePlayInEditorSession->SlatePlayInEditorWindow.Pin();
 
-					const FMovieSceneCaptureSettings& Settings = CaptureObject->GetSettings();
+					const FMovieSceneCaptureSettings& Settings = CurrentCaptureObject->GetSettings();
 
 					SlatePlayInEditorSession->SlatePlayInEditorWindowViewport->SetViewportSize(Settings.Resolution.ResX, Settings.Resolution.ResY);
 
@@ -171,30 +200,29 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 					FVector2D PreviewWindowPosition(50, 50);
 					Window->ReshapeWindow(PreviewWindowPosition, PreviewWindowSize);
 
-					if (CaptureObject->Settings.GameModeOverride != nullptr)
+					if (CurrentCaptureObject->Settings.GameModeOverride != nullptr)
 					{
 						CachedGameMode = CapturingFromWorld->GetWorldSettings()->DefaultGameMode;
-						CapturingFromWorld->GetWorldSettings()->DefaultGameMode = CaptureObject->Settings.GameModeOverride;
+						CapturingFromWorld->GetWorldSettings()->DefaultGameMode = CurrentCaptureObject->Settings.GameModeOverride;
 					}
 
-					CaptureObject->Initialize(SlatePlayInEditorSession->SlatePlayInEditorWindowViewport, Context.PIEInstance);
+					CurrentCaptureObject->Initialize(SlatePlayInEditorSession->SlatePlayInEditorWindowViewport, Context.PIEInstance);
 				}
 				return;
 			}
 		}
 
-		// todo: error?
 	}
 
 	void Shutdown()
 	{
 		FEditorDelegates::EndPIE.RemoveAll(this);
 		UGameViewportClient::OnViewportCreated().RemoveAll(this);
-		CaptureObject->OnCaptureFinished().RemoveAll(this);
+		CurrentCaptureObject->OnCaptureFinished().RemoveAll(this);
 
 		GAreScreenMessagesEnabled = bScreenMessagesWereEnabled;
 
-		if (!CaptureObject->Settings.bEnableTextureStreaming)
+		if (!CurrentCaptureObject->Settings.bEnableTextureStreaming)
 		{
 			IConsoleVariable* CVarStreamingPoolSize = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Streaming.PoolSize"));
 			if (CVarStreamingPoolSize)
@@ -209,7 +237,7 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 			}
 		}
 
-		if (CaptureObject->Settings.GameModeOverride != nullptr)
+		if (CurrentCaptureObject->Settings.GameModeOverride != nullptr)
 		{
 			CapturingFromWorld->GetWorldSettings()->DefaultGameMode = CachedGameMode;
 		}
@@ -222,46 +250,93 @@ struct FInEditorCapture : TSharedFromThis<FInEditorCapture>
 			AudioDevice->SetTransientMasterVolume(TransientMasterVolume);
 		}
 
-		CaptureObject->Close();
-		CaptureObject->RemoveFromRoot();
+		CurrentCaptureObject->Close();
+		//CurrentCaptureObject->RemoveFromRoot();
 
 	}
 	void OnEndPIE(bool bIsSimulating)
 	{
 		Shutdown();
-		OnlyStrongReference = nullptr;
+
+		Die();
+	}
+
+	void NextCapture(bool bIsSimulating)
+	{
+		
+		FEditorDelegates::EndPIE.RemoveAll(this);
+		// remove item from the TArray;
+		CaptureObjects.RemoveAt(0);
+
+		if (CaptureObjects.Num() > 0)
+		{
+			Dequeue();
+		}
+		else
+		{
+			Die();
+		}
 	}
 
 	void OnEnd()
 	{
 		Shutdown();
-		OnlyStrongReference = nullptr;
 
+		FEditorDelegates::EndPIE.AddRaw(this, &FInEditorMultiCapture::NextCapture);
 		GEditor->RequestEndPlayMap();
 	}
 
-	TSharedPtr<FInEditorCapture> OnlyStrongReference;
+	TSharedPtr<FInEditorMultiCapture> OnlyStrongReference;
 	UWorld* CapturingFromWorld;
 
 	bool bScreenMessagesWereEnabled;
 	float TransientMasterVolume;
 	int32 BackedUpStreamingPoolSize;
 	int32 BackedUpUseFixedPoolSize;
 	TArray<uint8> BackedUpPlaySettings;
-	UMovieSceneCapture* CaptureObject;
+	UMovieSceneCapture* CurrentCaptureObject;
 
 	TSubclassOf<AGameModeBase> CachedGameMode;
+	TArray<UMovieSceneCapture*> CaptureObjects;
 };
 
-PyObject *py_ue_in_editor_capture(ue_PyUObject * self, PyObject * args)
+PyObject *py_unreal_engine_in_editor_capture(PyObject * self, PyObject * args)
 {
-	ue_py_check(self);
+	PyObject *py_scene_captures;
 
-	UMovieSceneCapture *capture = ue_py_check_type<UMovieSceneCapture>(self);
+	if (!PyArg_ParseTuple(args, "O:in_editor_capture", &py_scene_captures))
+	{
+		return nullptr;
+	}
+
+	TArray<UMovieSceneCapture *> Captures;
+
+	UMovieSceneCapture *capture = ue_py_check_type<UMovieSceneCapture>(py_scene_captures);
 	if (!capture)
-		return PyErr_Format(PyExc_Exception, "uobject is not a UMovieSceneCapture");
+	{
+		PyObject *py_iter = PyObject_GetIter(py_scene_captures);
+		if (!py_iter)
+		{
+			return PyErr_Format(PyExc_Exception, "argument is not a UMovieSceneCapture or an iterable of UMovieSceneCapture");
+		}
+		while (PyObject *py_item = PyIter_Next(py_iter))
+		{
+			capture = ue_py_check_type<UMovieSceneCapture>(py_item);
+			if (!capture)
+			{
+				Py_DECREF(py_iter);
+				return PyErr_Format(PyExc_Exception, "argument is not an iterable of UMovieSceneCapture");
+			}
+			Captures.Add(capture);
+		}
+		Py_DECREF(py_iter);
+	}
+	else
+	{
+		Captures.Add(capture);
+	}
 
-	FInEditorCapture::CreateInEditorCapture(capture);
+	FInEditorMultiCapture::CreateInEditorMultiCapture(Captures);
 
 	Py_RETURN_NONE;
 }