diff options
Diffstat (limited to 'Runtime/Mono/MonoUtility.h')
| -rw-r--r-- | Runtime/Mono/MonoUtility.h | 556 |
1 files changed, 556 insertions, 0 deletions
diff --git a/Runtime/Mono/MonoUtility.h b/Runtime/Mono/MonoUtility.h new file mode 100644 index 0000000..147d1ec --- /dev/null +++ b/Runtime/Mono/MonoUtility.h @@ -0,0 +1,556 @@ +#ifndef MONOUTILITY_H +#define MONOUTILITY_H + +#if !defined(SCRIPTINGUTILITY_H) +#error "Don't include MonoUtility.h, include ScriptingUtility.h instead" +#endif + +#include "Configuration/UnityConfigure.h" +#include "Runtime/BaseClasses/BaseObject.h" +#include "Runtime/Mono/MonoManager.h" +#include "Runtime/Profiler/Profiler.h" +#include "Runtime/Scripting/Backend/ScriptingTypes.h" +#include "Runtime/Utilities/dynamic_array.h" +#include "Runtime/Scripting/Backend/ScriptingBackendApi.h" +#include "Runtime/Scripting/Scripting.h" +#include "Runtime/Scripting/ScriptingManager.h" + +//Unity messes around deep in mono internals, bypassing mono's API to do certain things. One of those things is we have c++ +//structs that we assume are identical to c# structs, and when a mono method calls into the unity runtime, we make the assumption +//that we can access the data stored in the c# struct directly. When a MonoObject* gets passed to us by mono, and we know that the +//object it represents is a struct, we take the MonoObject*, add 8 bytes, and assume the data of the c# struct is stored there in memory. +//When you update to a newer version of mono, and get weird crashes, the assumptions that these offsets make are a good one to verify. +enum { kMonoObjectOffset = sizeof(void*) * 2 }; +enum { kMonoArrayOffset = sizeof(void*) * 4 }; + +#if UNITY_EDITOR +bool IsStackLargeEnough (); +void AssertStackLargeEnough (); +#undef SCRIPTINGAPI_STACK_CHECK +#define SCRIPTINGAPI_STACK_CHECK(NAME) AssertStackLargeEnough(); +#endif + +// TODO: move +struct UnityEngineObjectMemoryLayout +{ + int instanceID; + void* cachedPtr; + +#if MONO_QUALITY_ERRORS + MonoString* error; +#endif +}; + +struct MonoObject; +struct MonoClass; +struct MonoException; +struct MonoArray; +class TrackedReferenceBase; + + +#if UNITY_WII +#define SCRIPTINGAPI_DEFINE_REF_ARG(t, n) MonoObject* _ ## n ## __mObject +#define SCRIPTINGAPI_FIX_REF_ARG(t, n) t n; n.object = _ ## n ## __mObject; +#else +#define SCRIPTINGAPI_DEFINE_REF_ARG(t, n) t n +#define SCRIPTINGAPI_FIX_REF_ARG(t, n) +#endif + +/* + Every MonoObject* that wraps an Object class contains the Reference::Data struct. + It contains the instanceID and a cachedPtr. + Only DEPLOY_OPTIMIZED mode (Player in release build) uses the cached ptr + + Normally we play safe and always dereference the pptr and also explicitly check + for null so we catch null ptr's before dereferencing. + + Referenced objects can of course be destroyed, resulting in stable cachedPtr's + Why does this work? + + If the script code expects that a reference might become null it needs to check against null. + if (transform == null) + If the script code does not check and the referenced is deleted, + then a null exception will be thrown in the editor. + In the DEPLOY_OPTIZMIZED mode no exception will be thrown but the program will just crash. + This means that a game has to ship with no null exception thrown in the editor or debug player. +*/ + +template<class T> +inline T* ExtractMonoObjectDataPtr (MonoObject* object) +{ + return reinterpret_cast<T*> (reinterpret_cast<char*> (object) + kMonoObjectOffset); +} + +template<class T> +inline T& ExtractMonoObjectData (MonoObject* object) +{ + return *reinterpret_cast<T*> (reinterpret_cast<char*> (object) + kMonoObjectOffset); +} + + +inline ScriptingObjectPtr ScriptingInstantiateObject(ScriptingClassPtr klass) +{ +#if UNITY_EDITOR + if (mono_unity_class_is_abstract (klass)) { + // Cannot instantiate abstract class + return SCRIPTING_NULL; + } +#endif + return mono_object_new(mono_domain_get(),klass); +} + +template<class T> inline +void MarshallManagedStructIntoNative(ScriptingObjectPtr so, T* dest) +{ + *dest = ExtractMonoObjectData<T>(so); +} + +template<class T> inline +void MarshallNativeStructIntoManaged(const T& src, ScriptingObjectPtr dest) +{ + ExtractMonoObjectData<T>(dest) = src; +} + + +// If MonoClass is derived from any UnityEngine class returns its classID +// otherwise returns -1. + +void mono_runtime_object_init_exception (MonoObject *thiss, MonoException** exception); +void mono_runtime_object_init_log_exception (MonoObject *thiss); + +template<class T> +inline T& GetMonoArrayElement (MonoArray* array, int i) +{ + return Scripting::GetScriptingArrayElement<T>(array,i); +} + + +inline void* GetMonoArrayPtr(MonoArray* array) +{ + return (void*) (((char*) array) + kMonoArrayOffset); +} + +template<class T> +inline T* GetMono2DArrayData (MonoArray* array) +{ + char* raw = kMonoArrayOffset + sizeof(guint32) + (char*)array; + return (T*)raw; +} + + +template<class T> +inline T* GetMono3DArrayData (MonoArray* array) +{ + char* raw = kMonoArrayOffset + sizeof(guint32)*2 + (char*)array; + return (T*)raw; +} + +int MonoDomainGetUniqueId(); +void MonoDomainIncrementUniqueId(); + +int mono_array_length (MonoArray* array); +int mono_array_length_safe (MonoArray* array); + +std::string MonoStringToCpp (MonoString* monoString); +std::string MonoStringToCppChecked (MonoObject* monoString); + +#if UNITY_WIN || UNITY_XENON +std::wstring MonoStringToWideCpp (MonoString* monoString); +#endif + +MonoString* MonoStringNew (const std::string& in); +MonoString* MonoStringNew (const char* in); +MonoString* MonoStringNewLength (const char* in, int length); +MonoString* MonoStringNewUTF16 (const wchar_t* in); +ScriptingStringPtr MonoStringFormat (const char* format, ...); + +bool ExceptionToLineAndPath (const std::string& exception, int& line, std::string& path); +bool MonoObjectToBool (MonoObject* value); +int MonoObjectToInt (MonoObject* value); +MonoMethod* mono_reflection_method_get_method (MonoObject* ass); +MonoString* MonoStringFormat (const char* format, ...); +MonoArray *mono_array_new_3d (int size0, int size1, int size2, MonoClass *klass); +MonoArray *mono_array_new_2d (int size0, int size1, MonoClass *klass); +MonoAssembly* mono_load_assembly_from_any_monopath(const char* assemblyname); +MonoMethod* mono_unity_find_method(const char* assemblyname, const char* ns, const char* klass, const char* methodname); +MonoObject* mono_class_get_object (MonoClass* klass); +MonoClass* mono_type_get_class_or_element_class (MonoType* type); +MonoString* UnassignedReferenceString (MonoObject* instance, int classID, MonoClassField* field, int instanceID); + +bool IsUtf16InAsciiRange( gunichar2 const* str, int length ); +bool FastTestAndConvertUtf16ToAscii( char* dest, gunichar2 const* str, int length ); +// str must contain only ascii characters +void FastUtf16ToAscii( char* destination, gunichar2 const* str, int length ); + +// Helper functions to go over a C++ vector<arbitrary struct> & create a MonoArray of it. +// it runs a template function on it in order to do the actual conversion of each object +/* Example usage: +C++RAW +struct MonoTreePrototype { + MonoObject *prefab; +}; + +void TreePrototypeToMono (TreePrototype &src, MonoTreePrototype &dest) { + dest.prefab = ObjectToScriptingObject (src.prefab); +} + +void TreePrototypeToCpp (MonoTreePrototype &src, TreePrototype &dest) { + dest.prefab = MonoObjectToObject<GameObject> (src.prefab); +} + + +CUSTOM_PROP TreePrototype[] treePrototypes + { return VectorToMonoStructArray<TreePrototype, MonoTreePrototype> (self->GetTreePrototypes(), MONO_COMMON.treePrototype, TreePrototypeToMono); } + { MonoStructArrayToVector<TreePrototype, MonoTreePrototype> (value, self->GetTreePrototypes(), TreePrototypeToCpp); } +*/ + +template<class T, typename Alloc> +void MonoObjectArrayToSet (MonoArray *array, std::set<T*, std::less<T*>, Alloc >& dest) { + Scripting::RaiseIfNull (array); + int len = mono_array_length_safe(array); + dest.clear(); + for (int i = 0; i < len;i++) + { + int instanceID = Scripting::GetInstanceIDFromScriptingWrapper(GetMonoArrayElement<MonoObject*>(array, i)); + T* objectPtr = dynamic_instanceID_cast<T*> (instanceID); + if (objectPtr) + dest.insert(objectPtr); + } +} + +template<class T> +void MonoArrayToSet(MonoArray* array, std::set<T>& dest) +{ + Scripting::RaiseIfNull (array); + int len = mono_array_length_safe(array); + dest.clear(); + for (int i = 0; i < len;i++) + { + dest.insert(GetMonoArrayElement<T>(array, i)); + } +} + +template<typename T> +MonoArray* SetToMonoArray(const std::set<T>& src, MonoClass* klass) +{ + MonoArray* array = mono_array_new (mono_domain_get (), klass, src.size()); + + typename std::set<T>::const_iterator j = src.begin(); + for (int i=0;i<src.size();i++, j++) + { + Scripting::SetScriptingArrayElement(array, i, *j); + } + + return array; +} + +template<class T> +void MonoArrayToVector(MonoArray* array, std::vector<T>& dest) +{ + Scripting::RaiseIfNull (array); + int len = mono_array_length_safe(array); + dest.resize (len); + for (int i = 0; i < len; i++) + dest[i] = GetMonoArrayElement<T>(array, i); +} + + +template<class T, class T2, class U, class TConverter> +MonoArray *VectorToMonoStructArray (const U &source, MonoClass *klass, TConverter converter) { + MonoArray *arr = mono_array_new (mono_domain_get (), klass, source.size()); + for (int i = 0; i < source.size();i++) + converter (source[i], GetMonoArrayElement<T2> (arr, i)); + return arr; +} + +template<class T, class T2> +void MonoStructArrayToVector (MonoArray *source, std::vector<T> &dest, void (*converter) (T2 &source, T &dest)) { + Scripting::RaiseIfNull (source); + int len = mono_array_length(source); + dest.resize (len); + for (int i = 0; i < len;i++) + converter (GetMonoArrayElement<T2> (source, i), dest[i]); +} + +template<class T, class T2> +std::vector<T> MonoStructArrayToVector (MonoArray *source, void (*converter) (T2 &source, T &dest)) { + std::vector<T> dest; + MonoStructArrayToVector<T, T2> (source, dest, converter); + return dest; +} + +template<class T, class T2, class U> +MonoArray *VectorToMonoClassArray (const U &source, MonoClass *klass, void (*converter) (const T &source, T2 &dest)) { + MonoArray *arr = mono_array_new (mono_domain_get (), klass, source.size()); + for (int i = 0; i < source.size();i++) { + MonoObject *obj = ScriptingInstantiateObject (klass); + GetMonoArrayElement<MonoObject*> (arr,i) = obj; + converter (source[i], ExtractMonoObjectData<T2> (obj)); + } + return arr; +} + +template<class T, class T2> +MonoArray *SetToMonoClassArray (const std::set<T> &source, MonoClass *klass, void (*converter) (const T &source, T2 &dest)) { + MonoArray *arr = mono_array_new (mono_domain_get (), klass, source.size()); + int idx = 0; + for (typename std::set<T>::const_iterator i = source.begin(); i != source.end();i++) { + MonoObject *obj = ScriptingInstantiateObject (klass); + GetMonoArrayElement<MonoObject*> (arr,idx++) = obj; + converter (*i, ExtractMonoObjectData<T2> (obj)); + } + return arr; +} + +template<typename mapType, class T, class T2, class T3> +MonoArray *MapToMonoClassArray (const mapType &source, MonoClass *klass, void (*converter) (const T &first, const T2 &second, T3 &dest)) { + MonoArray *arr = mono_array_new (mono_domain_get (), klass, source.size()); + int idx = 0; + for (typename mapType::const_iterator i = source.begin(); i != source.end();i++) { + MonoObject *obj = ScriptingInstantiateObject (klass); + GetMonoArrayElement<MonoObject*> (arr,idx++) = obj; + converter (i->first, i->second, ExtractMonoObjectData<T3> (obj)); + } + return arr; +} + +template<class T, class T2> +void MonoClassArrayToVector (MonoArray *source, std::vector<T> &dest, void (*converter) (T2 &source, T &dest)) { + Scripting::RaiseIfNull (source); + int len = mono_array_length(source); + dest.resize (len); + for (int i = 0; i < len;i++) { + MonoObject *obj = GetMonoArrayElement<MonoObject*> (source, i); + Scripting::RaiseIfNull (obj); + converter (ExtractMonoObjectData<T2> (obj), dest[i]); + } +} + +template<class T, class T2> +std::vector<T> MonoClassArrayToVector (MonoArray *source, void (*converter) (T2 &source, T &dest)) { + std::vector<T> dest; + MonoClassArrayToVector<T, T2> (source, dest, converter); + return dest; +} + +void StringMonoArrayToVector (MonoArray* arr, std::vector<std::string>& container); +void StringMonoArrayToVector (MonoArray* arr, std::vector<UnityStr>& container); + +inline ScriptingClassPtr GetScriptingTypeOfScriptingObject(ScriptingObjectPtr object) +{ + return mono_object_get_class(object); +} + +inline bool ScriptingClassIsSubclassOf(ScriptingClassPtr c1, ScriptingClassPtr c2) +{ + return mono_class_is_subclass_of(c1,c2,true); +} + +ScriptingClassPtr GetBuiltinScriptingClass(const char* name,bool optional=false); + +inline int GetScriptingArraySize(ScriptingArrayPtr a) +{ + return mono_array_length_safe(a); +} + + +/* + Code for switching between mono_runtime_invoke and mono_aot_get_method + (later mono_method_get_unmanaged_thunk also will be included) + */ + +void* ResolveMonoMethodPointer(MonoDomain *domain, MonoMethod *method); +bool MonoSetObjectField(MonoObject* target, const char* fieldname, MonoObject* value); +#if UNITY_EDITOR +bool IsStackLargeEnough (); +#endif + +// Ensure current thread is attached to mono, +// error and return otherwise +#define MONO_RUNTIME_INVOKE_THREAD_CHECK_WITH_RET(Ret) \ +do{ \ + if (!mono_thread_current ()) { \ + ErrorStringWithoutStacktrace ("Thread is not attached to scripting runtime"); \ + return Ret; \ + } \ +} while (0) + +#define MONO_RUNTIME_INVOKE_THREAD_CHECK MONO_RUNTIME_INVOKE_THREAD_CHECK_WITH_RET(NULL) + +// Ensure we have enough stack for a reasonable invocation +#if UNITY_EDITOR +#define MONO_RUNTIME_INVOKE_STACK_CHECK_WITH_RET(Ret) \ +do { \ + if (!IsStackLargeEnough ()) { \ + *exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "StackOverflowException", ""); \ + return Ret; \ + } \ +} while (0) + +#define MONO_RUNTIME_INVOKE_STACK_CHECK MONO_RUNTIME_INVOKE_STACK_CHECK_WITH_RET(NULL) +#else +#define MONO_RUNTIME_INVOKE_STACK_CHECK_WITH_RET(Ret) do {} while (0) +#define MONO_RUNTIME_INVOKE_STACK_CHECK do {} while (0) +#endif + +inline MonoObject* mono_runtime_invoke_profiled_fast (ScriptingMethodPtr method, MonoObject* obj, MonoException** exc, MonoClass* profileClassForCoroutine) +{ + MONO_RUNTIME_INVOKE_THREAD_CHECK; + MONO_RUNTIME_INVOKE_STACK_CHECK; + + MONO_PROFILER_BEGIN(method,profileClassForCoroutine, obj); + + MonoObject* ret; +#if USE_MONO_AOT + if (method->fastMonoMethod) + ret = method->fastMonoMethod(obj, exc); + else +#endif + ret = mono_runtime_invoke(method->monoMethod, obj, NULL, exc); + + MONO_PROFILER_END; + + return ret; +} + + +/// returns false if an exception was thrown +inline bool mono_runtime_invoke_profiled_fast_bool (MonoMethod* method, FastMonoMethod fastMethod, MonoObject* obj, MonoException** exc, MonoClass* profileClassForCoroutine) +{ + Assert(USE_MONO_AOT || fastMethod == NULL ); + Assert(exc != NULL); + + MONO_RUNTIME_INVOKE_THREAD_CHECK_WITH_RET(false); + MONO_RUNTIME_INVOKE_STACK_CHECK_WITH_RET(false); + + MONO_PROFILER_BEGIN(GetScriptingMethodRegistry().GetMethod(method), profileClassForCoroutine, obj); + + bool result = false; +#if USE_MONO_AOT + if (fastMethod) + result = fastMethod(obj, exc); + else +#endif + { + MonoObject* _tmpres = mono_runtime_invoke(method, obj, NULL, exc); + if (_tmpres != NULL && *exc == NULL) + result = ExtractMonoObjectData<char>(_tmpres); + } + + MONO_PROFILER_END; + + return result; +} + +/// Never call mono_runtime_invoke directly, otherwise the profiler will not be able to pick it up! +inline MonoObject* mono_runtime_invoke_profiled (MonoMethod *method, MonoObject *obj, void **params, MonoException **exc, MonoClass* classContextForProfiler=NULL) +{ + MONO_RUNTIME_INVOKE_THREAD_CHECK; + MONO_RUNTIME_INVOKE_STACK_CHECK; + + MONO_PROFILER_BEGIN (GetScriptingMethodRegistry().GetMethod(method), classContextForProfiler, obj); + MonoObject* ret = mono_runtime_invoke(method, obj, params, exc); + MONO_PROFILER_END; + + return ret; +} + +template<class T> +ScriptingObjectPtr CreateScriptingObjectFromNativeStruct(ScriptingClassPtr klass, T& thestruct) +{ + ScriptingObjectPtr mono = ScriptingInstantiateObject (klass); + T& destStruct = ExtractMonoObjectData<T> (mono); + destStruct = thestruct; + return mono; +} + +inline +char* ScriptingStringToAllocatedChars(const ICallString& str) +{ + return mono_string_to_utf8(str.str); +} + +MonoClassField* GetMonoArrayFieldFromList (int type, MonoType* monoType, MonoClassField* field); + +int EXPORT_COREMODULE mono_array_length_safe_wrapper(MonoArray* array); + +inline void ScriptingStringToAllocatedChars_Free(const char* str) +{ + g_free((void*)str); +} + +template<class T> +struct ScriptingObjectOfType; + +template<class T> +inline T* ScriptingObjectToObject(ScriptingObjectPtr so) +{ + ScriptingObjectOfType<T> ref(so); + return ref.GetPtr(); +} + +MonoClassField* GetMonoArrayFieldFromList (int type, MonoType* monoType, MonoClassField* field); + +/// ToDo: remove these (MonoObjectArrayToVector, MonoObjectArrayToPPtrVector) later, or change it to more unified version +/// vector<GameObject*> gos; +/// gos = MonoObjectArrayToVector(MonoArray*); +template<class T> +void MonoObjectArrayToVector (MonoArray *source, std::vector<T*>& dest) { + Scripting::RaiseIfNull (source); + int len = mono_array_length(source); + dest.resize (len); + for (int i = 0; i < len;i++) + dest[i] = ScriptingObjectToObject<T> (GetMonoArrayElement<MonoObject*> (source, i)); +} + +/// vector<GameObject*> gos; +/// gos = MonoObjectArrayToVector(MonoArray*); +template<class T> +void MonoObjectArrayToPPtrVector (MonoArray *source, std::vector<PPtr<T> >& dest) { + Scripting::RaiseIfNull (source); + int len = mono_array_length(source); + dest.resize (len); + for (int i = 0; i < len;i++) + dest[i] = ScriptingObjectToObject<T> (GetMonoArrayElement<MonoObject*> (source, i)); +} + +template<class T> +inline ScriptingObjectPtr ScriptingGetObjectReference(PPtr<T> object) +{ + return ObjectToScriptingObject(object); +} + +template<class T> +inline ScriptingObjectPtr ScriptingGetObjectReference(T* object) +{ + return Scripting::ScriptingWrapperFor(object); +} + +#define CreateScriptingParams(VariableName, ParamCount) ScriptingParams VariableName[ParamCount]; +// Don't use if Value is ScriptingObjectPtr!!! +#define SetScriptingParam(VariableName, Index, Value) VariableName[Index] = &Value; +#define GetSafeString(ClassName, Getter) Getter + +std::string ErrorMessageForUnsupportedEnumField(MonoType* enumType, MonoType* classType, const char * fieldName); + +MonoObject* MonoObjectNULL (int classID, MonoString* error); + +namespace Unity { class GameObject; class Component;} +class Object; + +#if MONO_QUALITY_ERRORS +// Wrap null ptr with pseudo null object +ScriptingObjectPtr MonoObjectNULL (ScriptingClassPtr klass, ScriptingStringPtr error); +inline ScriptingObjectPtr MonoObjectNULL (ScriptingClassPtr klass){ return MonoObjectNULL (klass, SCRIPTING_NULL); } + +// Component missing string error +MonoString* MissingComponentString (Unity::GameObject& go, int classID); +MonoString* MissingComponentString (Unity::GameObject& go, ScriptingTypePtr klass); + +#else + +inline ScriptingObjectPtr MonoObjectNULL (ScriptingClassPtr klass) { return SCRIPTING_NULL; } + +#endif + +#endif//ENABLE_MONO |