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));
}
