public static bool CanBeCast <T>(Il2CppObjectBase obj) where T : Il2CppObjectBase { IntPtr nativeClassPtr = Il2CppClassPointerStore <T> .NativeClassPtr; IntPtr num = IL2CPP.il2cpp_object_get_class(obj.Pointer); return(IL2CPP.il2cpp_class_is_assignable_from(nativeClassPtr, num)); }
public static void ProcessNewObject(Il2CppObjectBase obj) { var pointer = obj.Pointer; var handle = GCHandle.Alloc(obj, GCHandleType.Normal); AssignGcHandle(pointer, handle); }
// Unbox an il2cpp object to a struct or System primitive. public object UnboxCppObject(Il2CppObjectBase cppObj, Type toType) { if (!toType.IsValueType) { return(null); } try { if (toType.IsEnum) { return(Enum.Parse(toType, cppObj.ToString())); } var name = toType.AssemblyQualifiedName; if (!unboxMethods.ContainsKey(name)) { unboxMethods.Add(name, typeof(Il2CppObjectBase) .GetMethod("Unbox") .MakeGenericMethod(toType)); } return(unboxMethods[name].Invoke(cppObj, ArgumentUtility.EmptyArgs)); } catch (Exception ex) { ExplorerCore.LogWarning("Exception Unboxing Il2Cpp object to struct: " + ex); return(null); } }
/// <summary> /// Version of TryCast without the generic restriction /// </summary> private static bool TryCast <T>(Il2CppObjectBase obj, out T t) { t = default; var nativeClassPtr = Il2CppClassPointerStore <T> .NativeClassPtr; if (nativeClassPtr == IntPtr.Zero) { MelonLogger.Warning($"{typeof(T)} is not an Il2Cpp reference type"); return(false); } var num = IL2CPP.il2cpp_object_get_class(obj.Pointer); if (!IL2CPP.il2cpp_class_is_assignable_from(nativeClassPtr, num)) { MelonLogger.Warning($"{obj.GetType()} is not a {typeof(T)}"); return(false); } if (RuntimeSpecificsStore.IsInjected(num)) { t = (T)ClassInjectorBase.GetMonoObjectFromIl2CppPointer(obj.Pointer); return(true); } var type = Il2CppClassPointerStore <T> .CreatedTypeRedirect; if ((object)type == null) { type = typeof(T); } t = (T)Activator.CreateInstance(type, obj.Pointer); return(true); }
public static bool Is <T>(this Il2CppObjectBase obj) { var nestedTypeClassPointer = Il2CppClassPointerStore <T> .NativeClassPtr; if (nestedTypeClassPointer == IntPtr.Zero) { throw new ArgumentException($"{typeof(T)} is not an Il2Cpp reference type"); } var ownClass = IL2CPP.il2cpp_object_get_class(obj.Pointer); if (!IL2CPP.il2cpp_class_is_assignable_from(nestedTypeClassPointer, ownClass)) { return(false); } if (RuntimeSpecificsStore.IsInjected(ownClass)) { return(ClassInjectorBase.GetMonoObjectFromIl2CppPointer(obj.Pointer) is T); } return(true); }
public static void DerivedConstructorBody(Il2CppObjectBase objectBase) { var ownGcHandle = GCHandle.Alloc(objectBase, GCHandleType.Normal); AssignGcHandle(objectBase.Pointer, ownGcHandle); }
public static bool IsCollected(this Il2CppObjectBase that) { var gcHandle = Il2CppUtilities.GetGarbageCollectionHandle(that); return(IL2CPP.il2cpp_gchandle_get_target(gcHandle) == IntPtr.Zero); }
public static bool TryCastTo <T>(this Il2CppObjectBase obj, out T cast) where T : Il2CppObjectBase { cast = obj.TryCast <T>(); return(cast != null); }
public Il2CppObjectBaseWrapper(Il2CppObjectBase obj) : base(obj) { }
public static object TryCast(this Il2CppObjectBase self, Type type) { return(AccessTools.Method(self.GetType(), nameof(Il2CppObjectBase.TryCast)).MakeGenericMethod(type).Invoke(self, Array.Empty <object>())); }
internal Il2CppValueField(Il2CppObjectBase obj, string fieldName) { _obj = obj; _fieldPtr = IL2CPP.GetIl2CppField(obj.ObjectClass, fieldName); }
public static IntPtr SafePointer(this Il2CppObjectBase instance) { return(IL2CPP.Il2CppObjectBaseToPtr(instance)); }
public static void setFieldValue(Il2CppObjectBase obj, string fieldName, Il2CppObjectBase value) => il2cpp_gc_wbarrier_set_field(obj.Pointer, getFieldAddress(obj, fieldName), value.Pointer);
static IntPtr getFieldAddress(Il2CppObjectBase obj, string fieldName) => IL2CPP.Il2CppObjectBaseToPtrNotNull(obj) + (int)IL2CPP.il2cpp_field_get_offset((IntPtr)obj.GetType().field("NativeFieldInfoPtr_" + fieldName).GetValue(null));
/// <summary> /// WARNING: Pubternal API (internal). Do not use. May change during any update. /// </summary> /// <param name="obj"></param> /// <returns></returns> #if IL2CPP public int GetHashCode(Il2CppObjectBase obj) { return(obj.Pointer.GetHashCode()); }
/// <summary> /// WARNING: Pubternal API (internal). Do not use. May change during any update. /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public bool Equals(Il2CppObjectBase x, Il2CppObjectBase y) { return(ReferenceEquals(x, y) || (x != null && x.Pointer == y.Pointer)); }