split out run_on_gt

-also add callbacks on background thread calls

Author: getnamo

Content/Scripts/upythread.py

@@ -9,11 +9,14 @@ def backgroundAction(args=None):
 		callback = args[1]
 
 	#call the blocking action
-	action()
+	result = action()
 
 	#return the result if we have a callback
 	if callback:
-		ue.run_on_gt(callback)
+		if result is not None:
+			ue.run_on_gt(callback, result)
+		else:
+			ue.run_on_gt(callback)
 
 #run function on a background thread, optional callback when complete on game thread
 def run_on_bt(actionfunction, callback=None):

Source/UnrealEnginePython/Private/UEPyEngine.cpp

@@ -811,6 +811,95 @@ PyObject *py_unreal_engine_create_and_dispatch_when_ready(PyObject * self, PyObj
 }
 
 
+PyObject * py_unreal_engine_run_on_gt(PyObject *self, PyObject * args)
+{
+	PyObject *py_callable = nullptr;
+	PyObject *py_params = nullptr;
+
+	Py_ssize_t TupleSize = PyTuple_Size(args);
+
+	if (TupleSize == 1)
+	{
+		//function with no params
+		if (!PyArg_ParseTuple(args, "O:create_and_dispatch_when_ready", &py_callable))
+		{
+			UE_LOG(LogPython, Log, TEXT("PyArg_ParseTuple without params failed"));
+			unreal_engine_py_log_error();
+			return NULL;
+		}
+	}
+	else
+	{
+		//function with params
+		if (!PyArg_ParseTuple(args, "OO:create_and_dispatch_when_ready", &py_callable, &py_params))
+		{
+			UE_LOG(LogPython, Log, TEXT("PyArg_ParseTuple with params failed"));
+			unreal_engine_py_log_error();
+
+			//Not an acceptable format, exit
+			return NULL;
+		}
+	}
+
+	//UE_LOG(LogPython, Log, TEXT("Start Task in Game thread? %d"), IsInGameThread());
+
+	if (!PyCallable_Check(py_callable))
+	{
+		return PyErr_Format(PyExc_TypeError, "argument is not callable");
+	}
+
+	Py_INCREF(py_callable);
+	if (py_params)
+	{
+		Py_INCREF(py_params);
+	}
+
+	const PyObject* py_callable_s = py_callable;
+	const PyObject* py_params_s = py_params;
+
+
+	FGraphEventRef task = FFunctionGraphTask::CreateAndDispatchWhenReady([&, py_callable_s, py_params_s]() {
+		//UE_LOG(LogPython, Log, TEXT("In task graph, are in game thread? %d"), IsInGameThread());
+		FScopePythonGIL gil;
+		PyObject *ret = nullptr;
+		PyObject *py_tuple_params = nullptr;
+
+		//do we have parameters?
+		if (py_params_s)
+		{
+			py_tuple_params = PyTuple_New(1);
+			PyTuple_SetItem(py_tuple_params, 0, (PyObject*)py_params_s);
+			ret = PyObject_CallObject((PyObject*)py_callable_s, py_tuple_params);
+		}
+		else
+		{
+			ret = PyObject_CallObject((PyObject*)py_callable_s, nullptr);
+		}
+
+		//did we get a valid return from our call?
+		if (ret)
+		{
+			Py_DECREF(ret);
+		}
+		else
+		{
+			unreal_engine_py_log_error();
+		}
+		if (py_params_s)
+		{
+			Py_DECREF(py_params_s);
+		}
+		if (py_tuple_params)
+		{
+			Py_DECREF(py_tuple_params);
+		}
+		Py_DECREF(py_callable_s);
+	}, TStatId(), nullptr, ENamedThreads::GameThread);
+
+	Py_INCREF(Py_None);
+	Py_RETURN_NONE;
+}
+
 #if PLATFORM_MAC
 PyObject *py_unreal_engine_main_thread_call(PyObject * self, PyObject * args)
 {

Source/UnrealEnginePython/Private/UEPyEngine.h

@@ -65,6 +65,7 @@ PyObject *py_unreal_engine_get_mutable_default(PyObject *, PyObject *);
 
 
 PyObject *py_unreal_engine_create_and_dispatch_when_ready(PyObject *, PyObject *);
+PyObject *py_unreal_engine_run_on_gt(PyObject *, PyObject *);
 
 PyObject *py_unreal_engine_convert_relative_path_to_full(PyObject *, PyObject *);
 

Source/UnrealEnginePython/Private/UEPyModule.cpp

@@ -444,6 +444,7 @@ static PyMethodDef unreal_engine_methods[] = {
 
 
 	{ "create_and_dispatch_when_ready", py_unreal_engine_create_and_dispatch_when_ready, METH_VARARGS, "" },
+	{ "run_on_gt", py_unreal_engine_run_on_gt, METH_VARARGS, "" },
 #if PLATFORM_MAC
 	{ "main_thread_call", py_unreal_engine_main_thread_call, METH_VARARGS, "" },
 #endif
@@ -497,8 +498,6 @@ static PyMethodDef unreal_engine_methods[] = {
 
 	{ "in_editor_capture", py_unreal_engine_in_editor_capture, METH_VARARGS, "" },
 #endif
-	//duplicate for now for testing
-	{ "run_on_gt", py_unreal_engine_create_and_dispatch_when_ready, METH_VARARGS, "" },
 
 	{ "clipboard_copy", py_unreal_engine_clipboard_copy, METH_VARARGS, "" },
 	{ "clipboard_paste", py_unreal_engine_clipboard_paste, METH_VARARGS, "" },