604 lines
20 KiB
C++
604 lines
20 KiB
C++
// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "MTypes.h"
|
|
#include "MClass.h"
|
|
#include "MCore.h"
|
|
#include "Engine/Core/Types/StringView.h"
|
|
#include "Engine/Core/Types/DataContainer.h"
|
|
#include "Engine/Core/Types/Variant.h"
|
|
#include "Engine/Core/Collections/Array.h"
|
|
#include "Engine/Scripting/ScriptingObject.h"
|
|
|
|
#if USE_CSHARP
|
|
|
|
struct Version;
|
|
class CultureInfo;
|
|
template<typename AllocationType>
|
|
class BitArray;
|
|
|
|
namespace MUtils
|
|
{
|
|
extern FLAXENGINE_API StringView ToString(MString* str);
|
|
extern FLAXENGINE_API StringAnsi ToStringAnsi(MString* str);
|
|
extern FLAXENGINE_API void ToString(MString* str, String& result);
|
|
extern FLAXENGINE_API void ToString(MString* str, StringView& result);
|
|
extern FLAXENGINE_API void ToString(MString* str, Variant& result);
|
|
extern FLAXENGINE_API void ToString(MString* str, StringAnsi& result);
|
|
|
|
extern FLAXENGINE_API MString* ToString(const char* str);
|
|
extern FLAXENGINE_API MString* ToString(const StringAnsi& str);
|
|
extern FLAXENGINE_API MString* ToString(const String& str);
|
|
extern FLAXENGINE_API MString* ToString(const String& str, MDomain* domain);
|
|
extern FLAXENGINE_API MString* ToString(const StringAnsiView& str);
|
|
extern FLAXENGINE_API MString* ToString(const StringView& str);
|
|
extern FLAXENGINE_API MString* ToString(const StringView& str, MDomain* domain);
|
|
|
|
extern FLAXENGINE_API ScriptingTypeHandle UnboxScriptingTypeHandle(MTypeObject* value);
|
|
extern FLAXENGINE_API MTypeObject* BoxScriptingTypeHandle(const ScriptingTypeHandle& value);
|
|
extern FLAXENGINE_API VariantType UnboxVariantType(MType* type);
|
|
extern FLAXENGINE_API MTypeObject* BoxVariantType(const VariantType& value);
|
|
extern FLAXENGINE_API Variant UnboxVariant(MObject* value);
|
|
extern FLAXENGINE_API MObject* BoxVariant(const Variant& value);
|
|
}
|
|
|
|
// Converter for data of type T between managed and unmanaged world
|
|
template<typename T, typename Enable = void>
|
|
struct MConverter
|
|
{
|
|
MObject* Box(const T& data, const MClass* klass);
|
|
void Unbox(T& result, MObject* data);
|
|
void ToManagedArray(MArray* result, const Span<T>& data);
|
|
void ToNativeArray(Span<T>& result, const MArray* data);
|
|
};
|
|
|
|
// Converter for POD types (that can use raw memory copy).
|
|
template<typename T>
|
|
struct MConverter<T, typename TEnableIf<TAnd<TIsPODType<T>, TNot<TIsBaseOf<class ScriptingObject, typename TRemovePointer<T>::Type>>>::Value>::Type>
|
|
{
|
|
MObject* Box(const T& data, const MClass* klass)
|
|
{
|
|
return MCore::Object::Box((void*)&data, klass);
|
|
}
|
|
|
|
void Unbox(T& result, MObject* data)
|
|
{
|
|
CHECK(data);
|
|
Platform::MemoryCopy(&result, MCore::Object::Unbox(data), sizeof(T));
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<T>& data)
|
|
{
|
|
Platform::MemoryCopy(MCore::Array::GetAddress(result), data.Get(), data.Length() * sizeof(T));
|
|
}
|
|
|
|
void ToNativeArray(Span<T>& result, const MArray* data)
|
|
{
|
|
Platform::MemoryCopy(result.Get(), MCore::Array::GetAddress(data), result.Length() * sizeof(T));
|
|
}
|
|
};
|
|
|
|
// Converter for String.
|
|
template<>
|
|
struct MConverter<String>
|
|
{
|
|
MObject* Box(const String& data, const MClass* klass)
|
|
{
|
|
#if USE_NETCORE
|
|
MString* str = MUtils::ToString(data);
|
|
return MCore::Object::Box(str, klass);
|
|
#else
|
|
return (MObject*)MUtils::ToString(data);
|
|
#endif
|
|
}
|
|
|
|
void Unbox(String& result, MObject* data)
|
|
{
|
|
#if USE_NETCORE
|
|
MString* str = (MString*)MCore::Object::Unbox(data);
|
|
result = MUtils::ToString(str);
|
|
#else
|
|
result = MUtils::ToString((MString*)data);
|
|
#endif
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<String>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = (MObject*)MUtils::ToString(data.Get()[i]);
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<String>& result, const MArray* data)
|
|
{
|
|
MString** dataPtr = MCore::Array::GetAddress<MString*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
MUtils::ToString(dataPtr[i], result[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for StringAnsi.
|
|
template<>
|
|
struct MConverter<StringAnsi>
|
|
{
|
|
MObject* Box(const StringAnsi& data, const MClass* klass)
|
|
{
|
|
return (MObject*)MUtils::ToString(data);
|
|
}
|
|
|
|
void Unbox(StringAnsi& result, MObject* data)
|
|
{
|
|
result = MUtils::ToStringAnsi((MString*)data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<StringAnsi>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
auto* objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = (MObject*)MUtils::ToString(data.Get()[i]);
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<StringAnsi>& result, const MArray* data)
|
|
{
|
|
MString** dataPtr = MCore::Array::GetAddress<MString*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
MUtils::ToString(dataPtr[i], result[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for StringView.
|
|
template<>
|
|
struct MConverter<StringView>
|
|
{
|
|
MObject* Box(const StringView& data, const MClass* klass)
|
|
{
|
|
return (MObject*)MUtils::ToString(data);
|
|
}
|
|
|
|
void Unbox(StringView& result, MObject* data)
|
|
{
|
|
result = MUtils::ToString((MString*)data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<StringView>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = (MObject*)MUtils::ToString(data.Get()[i]);
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<StringView>& result, const MArray* data)
|
|
{
|
|
MString** dataPtr = MCore::Array::GetAddress<MString*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
MUtils::ToString(dataPtr[i], result[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for Variant.
|
|
template<>
|
|
struct MConverter<Variant>
|
|
{
|
|
MObject* Box(const Variant& data, const MClass* klass)
|
|
{
|
|
return MUtils::BoxVariant(data);
|
|
}
|
|
|
|
void Unbox(Variant& result, MObject* data)
|
|
{
|
|
result = MUtils::UnboxVariant(data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<Variant>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = MUtils::BoxVariant(data[i]);
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<Variant>& result, const MArray* data)
|
|
{
|
|
MObject** dataPtr = MCore::Array::GetAddress<MObject*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
result[i] = MUtils::UnboxVariant(dataPtr[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for Scripting Objects (collection of pointers).
|
|
template<typename T>
|
|
struct MConverter<T*, typename TEnableIf<TIsBaseOf<class ScriptingObject, T>::Value>::Type>
|
|
{
|
|
MObject* Box(T* data, const MClass* klass)
|
|
{
|
|
return data ? data->GetOrCreateManagedInstance() : nullptr;
|
|
}
|
|
|
|
void Unbox(T*& result, MObject* data)
|
|
{
|
|
result = (T*)ScriptingObject::ToNative(data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<T*>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = data.Get()[i] ? data.Get()[i]->GetOrCreateManagedInstance() : nullptr;
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<T*>& result, const MArray* data)
|
|
{
|
|
MObject** dataPtr = MCore::Array::GetAddress<MObject*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
result[i] = (T*)ScriptingObject::ToNative(dataPtr[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for Scripting Objects (collection of values).
|
|
template<typename T>
|
|
struct MConverter<T, typename TEnableIf<TIsBaseOf<class ScriptingObject, T>::Value>::Type>
|
|
{
|
|
MObject* Box(const T& data, const MClass* klass)
|
|
{
|
|
return data.GetOrCreateManagedInstance();
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<T>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = data.Get()[i].GetOrCreateManagedInstance();
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
};
|
|
|
|
// Converter for ScriptingObject References.
|
|
template<typename T>
|
|
class ScriptingObjectReference;
|
|
|
|
template<typename T>
|
|
struct MConverter<ScriptingObjectReference<T>>
|
|
{
|
|
MObject* Box(const ScriptingObjectReference<T>& data, const MClass* klass)
|
|
{
|
|
return data.GetManagedInstance();
|
|
}
|
|
|
|
void Unbox(ScriptingObjectReference<T>& result, MObject* data)
|
|
{
|
|
result = (T*)ScriptingObject::ToNative(data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<ScriptingObjectReference<T>>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = data[i].GetManagedInstance();
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<ScriptingObjectReference<T>>& result, const MArray* data)
|
|
{
|
|
MObject** dataPtr = MCore::Array::GetAddress<MObject*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
result[i] = (T*)ScriptingObject::ToNative(dataPtr[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for Asset References.
|
|
template<typename T>
|
|
class AssetReference;
|
|
|
|
template<typename T>
|
|
struct MConverter<AssetReference<T>>
|
|
{
|
|
MObject* Box(const AssetReference<T>& data, const MClass* klass)
|
|
{
|
|
return data.GetManagedInstance();
|
|
}
|
|
|
|
void Unbox(AssetReference<T>& result, MObject* data)
|
|
{
|
|
result = (T*)ScriptingObject::ToNative(data);
|
|
}
|
|
|
|
void ToManagedArray(MArray* result, const Span<AssetReference<T>>& data)
|
|
{
|
|
if (data.Length() == 0)
|
|
return;
|
|
MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*));
|
|
for (int32 i = 0; i < data.Length(); i++)
|
|
objects[i] = data[i].GetManagedInstance();
|
|
MCore::GC::WriteArrayRef(result, Span<MObject*>(objects, data.Length()));
|
|
Allocator::Free(objects);
|
|
}
|
|
|
|
void ToNativeArray(Span<AssetReference<T>>& result, const MArray* data)
|
|
{
|
|
MObject** dataPtr = MCore::Array::GetAddress<MObject*>(data);
|
|
for (int32 i = 0; i < result.Length(); i++)
|
|
result[i] = (T*)ScriptingObject::ToNative(dataPtr[i]);
|
|
}
|
|
};
|
|
|
|
// Converter for Array.
|
|
template<typename T>
|
|
struct MConverter<Array<T>>
|
|
{
|
|
MObject* Box(const Array<T>& data, const MClass* klass)
|
|
{
|
|
if (!klass)
|
|
return nullptr;
|
|
MArray* result = MCore::Array::New(klass->GetElementClass(), data.Count());
|
|
MConverter<T> converter;
|
|
converter.ToManagedArray(result, Span<T>(data.Get(), data.Count()));
|
|
return (MObject*)result;
|
|
}
|
|
|
|
void Unbox(Array<T>& result, MObject* data)
|
|
{
|
|
const int32 length = data ? MCore::Array::GetLength((MArray*)data) : 0;
|
|
result.Resize(length);
|
|
MConverter<T> converter;
|
|
Span<T> resultSpan(result.Get(), length);
|
|
converter.ToNativeArray(resultSpan, (MArray*)data);
|
|
}
|
|
};
|
|
|
|
namespace MUtils
|
|
{
|
|
// Outputs the full typename for the type of the specified object.
|
|
extern FLAXENGINE_API const StringAnsi& GetClassFullname(MObject* obj);
|
|
|
|
// Returns the class of the provided object.
|
|
extern FLAXENGINE_API MClass* GetClass(MObject* object);
|
|
|
|
// Returns the class of the provided type.
|
|
extern FLAXENGINE_API MClass* GetClass(MTypeObject* type);
|
|
|
|
// Returns the class of the provided VariantType value.
|
|
extern FLAXENGINE_API MClass* GetClass(const VariantType& value);
|
|
|
|
// Returns the class of the provided Variant value.
|
|
extern FLAXENGINE_API MClass* GetClass(const Variant& value);
|
|
|
|
// Returns the type of the provided object.
|
|
extern FLAXENGINE_API MTypeObject* GetType(MObject* object);
|
|
|
|
// Returns the type of the provided class.
|
|
extern FLAXENGINE_API MTypeObject* GetType(MClass* klass);
|
|
|
|
/// <summary>
|
|
/// Boxes the native value into the managed object.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
/// <param name="valueClass">The value type class.</param>
|
|
template<class T>
|
|
MObject* Box(const T& value, const MClass* valueClass)
|
|
{
|
|
MConverter<T> converter;
|
|
return converter.Box(value, valueClass);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unboxes MObject to the native value of the given type.
|
|
/// </summary>
|
|
template<class T>
|
|
T Unbox(MObject* object)
|
|
{
|
|
MConverter<T> converter;
|
|
T result;
|
|
converter.Unbox(result, object);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Links managed array data to the unmanaged BytesContainer.
|
|
/// </summary>
|
|
/// <param name="arrayObj">The array object.</param>
|
|
/// <returns>The result data container with linked array data bytes (not copied).</returns>
|
|
extern FLAXENGINE_API BytesContainer LinkArray(MArray* arrayObj);
|
|
|
|
/// <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>
|
|
MArray* ToArray(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;
|
|
}
|
|
|
|
/// <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 AllocationType>
|
|
FORCE_INLINE MArray* ToArray(const Array<T, AllocationType>& data, const MClass* valueClass)
|
|
{
|
|
return MUtils::ToArray(Span<T>(data.Get(), data.Count()), valueClass);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts the managed array into native array container object.
|
|
/// </summary>
|
|
/// <param name="arrayObj">The managed array object.</param>
|
|
/// <returns>The output array.</returns>
|
|
template<typename T, typename AllocationType = HeapAllocation>
|
|
Array<T, AllocationType> ToArray(MArray* arrayObj)
|
|
{
|
|
Array<T, AllocationType> result;
|
|
const int32 length = arrayObj ? MCore::Array::GetLength(arrayObj) : 0;
|
|
result.Resize(length);
|
|
MConverter<T> converter;
|
|
Span<T> resultSpan(result.Get(), length);
|
|
converter.ToNativeArray(resultSpan, arrayObj);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts the managed array into native Span.
|
|
/// </summary>
|
|
/// <param name="arrayObj">The managed array object.</param>
|
|
/// <returns>The output array pointer and size.</returns>
|
|
template<typename T>
|
|
Span<T> ToSpan(MArray* arrayObj)
|
|
{
|
|
T* ptr = (T*)MCore::Array::GetAddress(arrayObj);
|
|
const int32 length = arrayObj ? MCore::Array::GetLength(arrayObj) : 0;
|
|
return Span<T>(ptr, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts the native array into native Span.
|
|
/// </summary>
|
|
/// <param name="data">The native array object.</param>
|
|
/// <returns>The output array pointer and size.</returns>
|
|
template<typename T, typename AllocationType = HeapAllocation>
|
|
FORCE_INLINE Span<T> ToSpan(const Array<T, AllocationType>& data)
|
|
{
|
|
return Span<T>(data.Get(), data.Count());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Links managed array data to the unmanaged DataContainer (must use simple type like struct or float/int/bool).
|
|
/// </summary>
|
|
/// <param name="arrayObj">The array object.</param>
|
|
/// <param name="result">The result data (linked not copied).</param>
|
|
template<typename T>
|
|
void ToArray(MArray* arrayObj, DataContainer<T>& result)
|
|
{
|
|
const int32 length = arrayObj ? MCore::Array::GetLength(arrayObj) : 0;
|
|
if (length == 0)
|
|
{
|
|
result.Release();
|
|
return;
|
|
}
|
|
T* bytesRaw = (T*)MCore::Array::GetAddress(arrayObj);
|
|
result.Link(bytesRaw, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates new managed bytes array and copies data from the given unmanaged data container.
|
|
/// </summary>
|
|
/// <param name="data">The input data.</param>
|
|
/// <returns>The output array.</returns>
|
|
FORCE_INLINE MArray* ToArray(const Span<byte>& data)
|
|
{
|
|
return ToArray(data, MCore::TypeCache::Byte);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates new managed bytes array and copies data from the given unmanaged data container.
|
|
/// </summary>
|
|
/// <param name="data">The input data.</param>
|
|
/// <returns>The output array.</returns>
|
|
FORCE_INLINE MArray* ToArray(Array<byte>& data)
|
|
{
|
|
return ToArray(Span<byte>(data.Get(), data.Count()), MCore::TypeCache::Byte);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates new managed strings array and copies data from the given unmanaged data container.
|
|
/// </summary>
|
|
/// <param name="data">The input data.</param>
|
|
/// <returns>The output array.</returns>
|
|
FORCE_INLINE MArray* ToArray(const Span<String>& data)
|
|
{
|
|
return ToArray(data, MCore::TypeCache::String);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates new managed strings array and copies data from the given unmanaged data container.
|
|
/// </summary>
|
|
/// <param name="data">The input data.</param>
|
|
/// <returns>The output array.</returns>
|
|
FORCE_INLINE MArray* ToArray(const Array<String>& data)
|
|
{
|
|
return ToArray(Span<String>(data.Get(), data.Count()), MCore::TypeCache::String);
|
|
}
|
|
|
|
#if USE_NETCORE
|
|
/// <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 bool* ToBoolArray(const Array<bool>& data)
|
|
{
|
|
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
|
|
bool* arr = (bool*)MCore::GC::AllocateMemory(data.Count() * sizeof(bool), true);
|
|
memcpy(arr, data.Get(), data.Count() * sizeof(bool));
|
|
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 AllocationType = HeapAllocation>
|
|
FORCE_INLINE bool* ToBoolArray(const BitArray<AllocationType>& data)
|
|
{
|
|
// System.Runtime.InteropServices.Marshalling.ArrayMarshaller uses CoTask memory alloc to native data pointer
|
|
bool* arr = (bool*)MCore::GC::AllocateMemory(data.Count() * sizeof(bool), true);
|
|
for (int i = 0; i < data.Count(); i++)
|
|
arr[i] = data[i];
|
|
return arr;
|
|
}
|
|
#else
|
|
FORCE_INLINE bool* ToBoolArray(const Array<bool>& data)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
template<typename AllocationType = HeapAllocation>
|
|
FORCE_INLINE bool* ToBoolArray(const BitArray<AllocationType>& data)
|
|
{
|
|
return nullptr;
|
|
}
|
|
#endif
|
|
|
|
extern void* VariantToManagedArgPtr(Variant& value, MType* type, bool& failed);
|
|
|
|
extern MObject* ToManaged(const Version& value);
|
|
extern Version ToNative(MObject* value);
|
|
};
|
|
|
|
#endif
|