brought up to date with master

Author: dfb

Source/UnrealEnginePython/Private/PyCommandlet.cpp

@@ -91,7 +91,7 @@ int32 UPyCommandlet::Main(const FString& CommandLine)
 #if PY_MAJOR_VERSION >= 3
 		argv[i] = (wchar_t*)malloc(PyArgv[i].Len() + 1);
 #if PLATFORM_MAC || PLATFORM_LINUX
-		wcsncpy(argv[i], *PyArgv[i].ReplaceEscapedCharWithChar(), PyArgv[i].Len() + 1);
+		wcsncpy(argv[i], (const wchar_t *) TCHAR_TO_WCHAR(*PyArgv[i].ReplaceEscapedCharWithChar()), PyArgv[i].Len() + 1);
 #elif PLATFORM_ANDROID
 		wcsncpy(argv[i], (const wchar_t *)*PyArgv[i].ReplaceEscapedCharWithChar(), PyArgv[i].Len() + 1);
 #else

Source/UnrealEnginePython/Private/UEPyModule.cpp

@@ -51,6 +51,7 @@
 #include "Wrappers/UEPyESlateEnums.h"
 
 #include "Wrappers/UEPyFVector.h"
+#include "Wrappers/UEPyFVector2D.h"
 #include "Wrappers/UEPyFHitResult.h"
 #include "Wrappers/UEPyFRotator.h"
 #include "Wrappers/UEPyFTransform.h"
@@ -1657,6 +1658,7 @@ void unreal_engine_init_py_module()
 	}
 
 	ue_python_init_fvector(new_unreal_engine_module);
+	ue_python_init_fvector2d(new_unreal_engine_module);
 	ue_python_init_frotator(new_unreal_engine_module);
 	ue_python_init_ftransform(new_unreal_engine_module);
 	ue_python_init_fhitresult(new_unreal_engine_module);
@@ -2106,12 +2108,16 @@ PyObject *ue_py_convert_property(UProperty *prop, uint8 *buffer, int32 index)
 	{
 		if (auto casted_struct = Cast<UScriptStruct>(casted_prop->Struct))
 		{
-			// check for FVector
 			if (casted_struct == TBaseStructure<FVector>::Get())
 			{
 				FVector vec = *casted_prop->ContainerPtrToValuePtr<FVector>(buffer, index);
 				return py_ue_new_fvector(vec);
 			}
+			if (casted_struct == TBaseStructure<FVector2D>::Get())
+			{
+				FVector2D vec = *casted_prop->ContainerPtrToValuePtr<FVector2D>(buffer, index);
+				return py_ue_new_fvector2d(vec);
+			}
 			if (casted_struct == TBaseStructure<FRotator>::Get())
 			{
 				FRotator rot = *casted_prop->ContainerPtrToValuePtr<FRotator>(buffer, index);
@@ -2517,6 +2523,19 @@ bool ue_py_convert_pyobject(PyObject *py_obj, UProperty *prop, uint8 *buffer, in
 		return false;
 	}
 
+	if (ue_PyFVector2D *py_vec = py_ue_is_fvector2d(py_obj))
+	{
+		if (auto casted_prop = Cast<UStructProperty>(prop))
+		{
+			if (casted_prop->Struct == TBaseStructure<FVector2D>::Get())
+			{
+				*casted_prop->ContainerPtrToValuePtr<FVector2D>(buffer, index) = py_vec->vec;
+				return true;
+			}
+		}
+		return false;
+	}
+
 	if (ue_PyFRotator *py_rot = py_ue_is_frotator(py_obj))
 	{
 		if (auto casted_prop = Cast<UStructProperty>(prop))
@@ -3086,6 +3105,12 @@ UProperty *new_property_from_pyobject(UObject *owner, const char *prop_name, PyO
             prop_struct->Struct = TBaseStructure<FVector>::Get();
             prop = prop_struct;
         }
+        else if ((PyTypeObject *)value == &ue_PyFVector2DType)
+        {
+            UStructProperty *prop_struct = NewObject<UStructProperty>(owner, UTF8_TO_TCHAR(prop_name), RF_Public);
+            prop_struct->Struct = TBaseStructure<FVector2D>::Get();
+            prop = prop_struct;
+        }
         else if ((PyTypeObject *)value == &ue_PyFRotatorType)
         {
             UStructProperty *prop_struct = NewObject<UStructProperty>(owner, UTF8_TO_TCHAR(prop_name), RF_Public);

Source/UnrealEnginePython/Private/UnrealEnginePython.cpp

@@ -34,9 +34,14 @@ const char *ue4_module_options = "linux_global_symbols";
 #include "Runtime/Core/Public/Misc/CommandLine.h"
 #include "Runtime/Core/Public/Misc/ConfigCacheIni.h"
 #include "Runtime/Core/Public/GenericPlatform/GenericPlatformFile.h"
+#include "Runtime/Core/Public/GenericPlatform/GenericPlatformMisc.h"
 
 #include "Runtime/Core/Public/HAL/FileManagerGeneric.h"
 
+#if PLATFORM_WINDOWS
+#include <fcntl.h>
+#endif
+
 #if PLATFORM_ANDROID
 #include "Android/AndroidJNI.h"
 #include "Android/AndroidApplication.h"
@@ -116,7 +121,7 @@ void FUnrealEnginePythonModule::UESetupPythonInterpreter(bool verbose)
 	for (int32 i = 0; i < Args.Num(); i++)
 	{
 #if PY_MAJOR_VERSION >= 3
-		argv[i] = (wchar_t *)(*Args[i]);
+		argv[i] = (wchar_t *)(TCHAR_TO_WCHAR(*Args[i]));
 #else
 		argv[i] = TCHAR_TO_UTF8(*Args[i]);
 #endif
@@ -451,6 +456,22 @@ void FUnrealEnginePythonModule::StartupModule()
 
 	Py_Initialize();
 
+#if PLATFORM_WINDOWS
+	// Restore stdio state after Py_Initialize set it to O_BINARY, otherwise
+	// everything that the engine will output is going to be encoded in UTF-16.
+	// The behaviour is described here: https://bugs.python.org/issue16587
+	_setmode(_fileno(stdin), O_TEXT);
+	_setmode(_fileno(stdout), O_TEXT);
+	_setmode(_fileno(stderr), O_TEXT);
+
+	// Also restore the user-requested UTF-8 flag if relevant (behaviour copied
+	// from LaunchEngineLoop.cpp).
+	if (FParse::Param(FCommandLine::Get(), TEXT("UTF8Output")))
+	{
+		FPlatformMisc::SetUTF8Output();
+	}
+#endif
+
 	PyEval_InitThreads();
 
 #if WITH_EDITOR

Source/UnrealEnginePython/Private/Wrappers/UEPyFVector.cpp

@@ -277,6 +277,24 @@ static PyObject *ue_py_fvector_div(ue_PyFVector *self, PyObject *value)
 	return py_ue_new_fvector(vec);
 }
 
+static PyObject *ue_py_fvector_floor_div(ue_PyFVector *self, PyObject *value)
+{
+	FVector vec = self->vec;
+	if (PyNumber_Check(value))
+	{
+		PyObject *f_value = PyNumber_Float(value);
+		float f = PyFloat_AsDouble(f_value);
+		if (f == 0)
+			return PyErr_Format(PyExc_ZeroDivisionError, "division by zero");
+		vec.X = floor(vec.X / f);
+		vec.Y = floor(vec.Y / f);
+		vec.Z = floor(vec.Z / f);
+		Py_DECREF(f_value);
+		return py_ue_new_fvector(vec);
+	}
+	return PyErr_Format(PyExc_TypeError, "value is not numeric");
+}
+
 PyNumberMethods ue_PyFVector_number_methods;
 
 static Py_ssize_t ue_py_fvector_seq_length(ue_PyFVector *self)
@@ -363,7 +381,8 @@ void ue_python_init_fvector(PyObject *ue_module)
 	ue_PyFVector_number_methods.nb_add = (binaryfunc)ue_py_fvector_add;
 	ue_PyFVector_number_methods.nb_subtract = (binaryfunc)ue_py_fvector_sub;
 	ue_PyFVector_number_methods.nb_multiply = (binaryfunc)ue_py_fvector_mul;
-	ue_PyFVector_number_methods.nb_divmod = (binaryfunc)ue_py_fvector_div;
+	ue_PyFVector_number_methods.nb_true_divide = (binaryfunc)ue_py_fvector_div;
+	ue_PyFVector_number_methods.nb_floor_divide = (binaryfunc)ue_py_fvector_floor_div;
 
 	memset(&ue_PyFVector_sequence_methods, 0, sizeof(PySequenceMethods));
 	ue_PyFVectorType.tp_as_sequence = &ue_PyFVector_sequence_methods;