GoaLitiuM/FlaxEngine
1
0
Fork 0
Code Issues Pull Requests Actions 7 Packages Projects Releases Wiki Activity

_prog
Some checks failed
Build Android / Game (Android, Release ARM64) (push) Has been cancelled
Details
Build iOS / Game (iOS, Release ARM64) (push) Has been cancelled
Details
Build Linux / Editor (Linux, Development x64) (push) Has been cancelled
Details
Build Linux / Game (Linux, Release x64) (push) Has been cancelled
Details
Build macOS / Editor (Mac, Development ARM64) (push) Has been cancelled
Details
Build macOS / Game (Mac, Release ARM64) (push) Has been cancelled
Details
Build Windows / Editor (Windows, Development x64) (push) Has been cancelled
Details
Build Windows / Game (Windows, Release x64) (push) Has been cancelled
Details
Cooker / Cook (Mac) (push) Has been cancelled
Details
Tests / Tests (Linux) (push) Has been cancelled
Details
Tests / Tests (Windows) (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Ari Vuollet
2025-12-27 17:59:40 +02:00
parent 523cad3b2c
commit c7326ea483
15 changed files with 1590 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

411
Source/Engine/Scripting/ManagedCLR/MUtils.h
View File

@@ -13,6 +13,12 @@
#if USE_CSHARP
/*static_assert(TIsPODType<int>::Value, "int not pod type?");
static_assert(TIsPODType<Float3>::Value, "Float3 not pod type?");
static_assert(!TIsPODType<ScriptingObject>::Value, "ScriptingObject not pod type?");
static_assert(TIsPODType<Char>::Value, "Char not pod type?");
static_assert(TIsPODType<char>::Value, "char not pod type?");*/
struct Version;
class CultureInfo;
template<typename AllocationType>
@@ -49,6 +55,12 @@ struct MConverter
{
MObject* Box(const T& data, const MClass* klass);
void Unbox(T& result, MObject* data);
/*template<typename U>
void ToManaged(U& result, const T& data);
template<typename U>
void ToNative(T& result, const U& data);
void ToManaged(MObject*& result, const T& data);
void ToNative(T& result, const MObject*& data);*/
void FreeManaged(MObject* data);
void ToManagedArray(MArray* result, const Span<T>& data);
void ToNativeArray(Span<T>& result, const MArray* data);
@@ -61,6 +73,16 @@ struct NativeArray
{
T* data;
int32 length;
FORCE_INLINE operator T*() const
{
return data;
}
FORCE_INLINE Span<T> ToSpan() const
{
return Span<T>(data, length);
}
};
#if USE_NETCORE
@@ -79,6 +101,16 @@ struct MConverter<bool>
MCore::Object::Unbox(data, &result);
}
void ToManaged(bool& result, const bool& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(bool& result, const bool& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void FreeManaged(MObject* data)
{
}
@@ -116,6 +148,16 @@ struct MConverter<T, typename TEnableIf<TAnd<TIsPODType<T>, TNot<TIsBaseOf<class
MCore::Object::Unbox(data, &result);
}
void ToManaged(T& result, const T& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(T& result, const T& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<T>& data)
{
Platform::MemoryCopy(MCore::Array::GetAddress(result), data.Get(), data.Length() * sizeof(T));
@@ -162,6 +204,16 @@ struct MConverter<String>
//#endif
}
void ToManaged(String& result, const String& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(String& result, const String& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<String>& data)
{
if (data.Length() == 0)
@@ -212,6 +264,16 @@ struct MConverter<StringAnsi>
result = MUtils::ToStringAnsi((MString*)data);
}
void ToManaged(StringAnsi& result, const StringAnsi& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(StringAnsi& result, const StringAnsi& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<StringAnsi>& data)
{
if (data.Length() == 0)
@@ -262,6 +324,16 @@ struct MConverter<StringView>
result = MUtils::ToString((MString*)data);
}
void ToManaged(StringView& result, const StringView& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(StringView& result, const StringView& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<StringView>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
@@ -316,6 +388,16 @@ struct MConverter<Variant>
result = MUtils::UnboxVariant(data);
}
void ToManaged(Variant& result, const Variant& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(Variant& result, const Variant& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<Variant>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
@@ -365,6 +447,18 @@ struct MConverter<T*, typename TEnableIf<TIsBaseOf<class ScriptingObject, T>::Va
result = (T*)ScriptingObject::ToNative(data);
}
void ToManaged(MObject*& result, const T* data)
{
//PLATFORM_DEBUG_BREAK; // FIXME
result = data ? data->GetOrCreateManagedInstance() : nullptr;
}
void ToNative(T*& result, const MObject* data)
{
PLATFORM_DEBUG_BREAK; // FIXME
result = (T*)ScriptingObject::ToNative(data);
}
void ToManagedArray(MArray* result, const Span<T*>& data)
{
if (data.Length() == 0)
@@ -405,9 +499,29 @@ struct MConverter<T, typename TEnableIf<TIsBaseOf<class ScriptingObject, T>::Val
return data.GetOrCreateManagedInstance();
}
void ToManagedArray(MArray* result, const Span<T>& data)
void ToManaged(MObject*& result, const T& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(T& result, const MObject*& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
/*void ToManaged(MObject*& result, const T*& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(T*& result, const MObject*& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}*/
void ToManagedArray(MArray* result, const Span<T>& data)
{
//PLATFORM_DEBUG_BREAK; // FIXME
if (data.Length() == 0)
return;
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
@@ -449,6 +563,16 @@ struct MConverter<ScriptingObjectReference<T>>
result = (T*)ScriptingObject::ToNative(data);
}
void ToManaged(MObject*& result, const ScriptingObjectReference<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(ScriptingObjectReference<T>& result, const MObject*& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<ScriptingObjectReference<T>>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
@@ -501,6 +625,17 @@ struct MConverter<AssetReference<T>>
result = (T*)ScriptingObject::ToNative(data);
}
void ToManaged(MObject*& result, const AssetReference<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
result = data.GetManagedInstance();
}
void ToNative(AssetReference<T>& result, const MObject* data)
{
result = (T*)ScriptingObject::ToNative(data);
}
void ToManagedArray(MArray* result, const Span<AssetReference<T>>& data)
{
if (data.Length() == 0)
@@ -538,6 +673,29 @@ class SoftAssetReference;
template<typename T>
struct MConverter<SoftAssetReference<T>>
{
template <typename U>
void ToManaged(U& result, const SoftAssetReference<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
template <typename U>
void ToNative(SoftAssetReference<T>& result, const U& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManaged(MObject*& result, const SoftAssetReference<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(SoftAssetReference<T>& result, const MObject*& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToManagedArray(MArray* result, const Span<SoftAssetReference<T>>& data)
{
//PLATFORM_DEBUG_BREAK; // FIXME
@@ -575,6 +733,16 @@ struct MConverter<SoftAssetReference<T>>
template<typename T>
struct MConverter<Array<T>>
{
void ToManaged(Array<T>& result, const Array<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
void ToNative(Array<T>& result, const Array<T>& data)
{
PLATFORM_DEBUG_BREAK; // FIXME
}
MObject* Box(const Array<T>& data, const MClass* klass)
{
PLATFORM_DEBUG_BREAK; // FIXME
@@ -877,12 +1045,36 @@ namespace MUtils
return arr;
}
/// <summary>
/// Allocates new managed array of data and copies contents from given native array.
/// </summary>
/// <param name="data">The array object.</param>
/// <param name="valueClass">The array values type class.</param>
/// <returns>The output array.</returns>
/*template<typename T, typename U>
NativeArray<U> ToManagedArrayWrapper(const Span<T>& data, const MClass* valueClass)
{
if (!valueClass)
return nullptr;
MArray* result = MCore::Array::New(valueClass, data.Length());
MConverter<T> converter;
converter.ToManagedArray(result, data);
return result;
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<U> arr;
arr.length = data.Count();
arr.data = (U*)MCore::GC::AllocateMemory(arr.length * sizeof(U), true);
Platform::MemoryCopy(arr.data, data.Get(), arr.length * sizeof(U));
return arr;
}*/
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T, typename AllocationType = HeapAllocation>
/*template<typename T, typename AllocationType = HeapAllocation>
FORCE_INLINE NativeArray<T> ToNativeArrayWrapper(const Array<T, AllocationType>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
@@ -893,22 +1085,233 @@ namespace MUtils
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T, typename U, typename AllocationType = HeapAllocation>
FORCE_INLINE NativeArray<U> ToNativeArrayWrapper(const Array<T, AllocationType>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<U> arr;
arr.length = data.Count();
arr.data = (U*)MCore::GC::AllocateMemory(arr.length * sizeof(U), true);
// Convert to managed
MConverter<T, U> converter;
for (int i = 0; i < arr.length; ++i)
arr.data[i] = converter.ToManaged(data[i]);
return arr;
}*/
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T, typename U>
FORCE_INLINE NativeArray<U> ToManagedArrayWrapperConvert(const Span<T>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<U> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (U*)MCore::GC::AllocateMemory(arr.length * sizeof(U), true) : nullptr;
// Convert to managed
MConverter<T, U> converter;
for (int i = 0; i < arr.length; ++i)
converter.ToManaged(arr.data[i], data[i]);
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T>
FORCE_INLINE NativeArray<T> ToNativeArrayWrapper(const Span<T>& data)
FORCE_INLINE NativeArray<T> ToNativeArrayWrapperConvertGeneric(const Span<MObject*>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<T> arr;
arr.length = data.Length();
arr.data = (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true);
arr.data = arr.length > 0 ? (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true) : nullptr;
// Convert to managed
MConverter<T> converter;
for (int i = 0; i < arr.length; ++i)
{
converter.ToNative(arr.data[i], data[i]);
}
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T, typename AllocationType = HeapAllocation>
FORCE_INLINE void ToNativeArrayWrapperConvertGeneric(const Span<MObject*>& data, Array<T, AllocationType>& array)
{
if (!array.IsEmpty())
PLATFORM_DEBUG_BREAK; // TODO: does the array require ClearDelete instead?
auto length = data.Length();
array.Resize(length, false);
//array.Clear();
//array.EnsureCapacity(length);
MConverter<T> converter;
for (int i = 0; i < length; ++i)
{
// Make sure the destination is default initialized first
//array.AddUninitialized();
//array.AddDefault();
//T& dest = array.Get()[i];
//new(&dest)AssetReference<T>();
// Convert from managed
converter.ToNative(array.Get()[i], data[i]);
}
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T, typename U>
FORCE_INLINE NativeArray<T> ToNativeArrayWrapperConvert(const Span<U>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<T> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true) : nullptr;
// Convert to managed
MConverter<T, U> converter;
for (int i = 0; i < arr.length; ++i)
converter.ToNative(arr.data[i], data[i]);
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T>
FORCE_INLINE NativeArray<T> ToNativeArrayWrapperCopy(const Span<T>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<T> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true) : nullptr;
Platform::MemoryCopy(arr.data, data.Get(), arr.length * sizeof(T));
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
/*FORCE_INLINE NativeArray<Char> ToManagedArrayWrapper(const Span<Char>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<Char> arr;
arr.length = data.Length();
arr.data = (Char*)MCore::GC::AllocateMemory(arr.length * sizeof(Char), true);
Platform::MemoryCopy(arr.data, data.Get(), arr.length * sizeof(Char));
return arr;
}*/
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T>
FORCE_INLINE NativeArray<T> ToManagedArrayWrapperConvert(const Span<T>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<T> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true) : nullptr;
//Platform::MemoryCopy(arr.data, data.Get(), arr.length * sizeof(T));
// Convert to managed
MConverter<T> converter;
for (int i = 0; i < arr.length; ++i)
converter.ToManaged(arr.data[i], data[i]);
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<typename T>
FORCE_INLINE NativeArray<T> ToManagedArrayWrapperCopy(const Span<T>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<T> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (T*)MCore::GC::AllocateMemory(arr.length * sizeof(T), true) : nullptr;
Platform::MemoryCopy(arr.data, data.Get(), arr.length * sizeof(T));
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
/*template<typename T>
FORCE_INLINE NativeArray<MObject*> ToManagedArrayWrapperPointer(const Span<T*>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<MObject*> arr;
arr.length = data.Length();
arr.data = (MObject**)MCore::GC::AllocateMemory(arr.length * sizeof(MObject*), true);
// Convert to managed
MConverter<T*> converter;
for (int i = 0; i < arr.length; ++i)
{
MObject*& ptr = arr.data[i];
const T& asd = data[i];
converter.ToManaged(ptr, asd);
}
return arr;
}*/
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>
/// <param name="data">The input data.</param>
/// <returns>The output array.</returns>
template<class T>
FORCE_INLINE NativeArray<MObject*> ToManagedArrayWrapperPointer(const Span<T>& data)
{
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
NativeArray<MObject*> arr;
arr.length = data.Length();
arr.data = arr.length > 0 ? (MObject**)MCore::GC::AllocateMemory(arr.length * sizeof(MObject*), true) : nullptr;
// Convert to managed
MConverter<T> converter;
for (int i = 0; i < arr.length; ++i)
converter.ToManaged(arr.data[i], data[i]);
return arr;
}
/// <summary>
/// Allocates new boolean array and copies data from the given unmanaged data container. The managed runtime is responsible for releasing the returned array data.
/// </summary>