50b603c7dc
We're targeting .NET 5 for now to make development easier while .NET 6 is not yet released. TEMPORARY REGRESSIONS --------------------- Assembly unloading is not implemented yet. As such, many Godot resources are leaked at exit. This will be re-implemented later together with assembly hot-reloading.
467 lines
16 KiB
C#
467 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using Godot.NativeInterop;
|
|
|
|
namespace Godot
|
|
{
|
|
internal static class DelegateUtils
|
|
{
|
|
[UnmanagedCallersOnly]
|
|
internal static godot_bool DelegateEquals(IntPtr delegateGCHandleA, IntPtr delegateGCHandleB)
|
|
{
|
|
try
|
|
{
|
|
var @delegateA = (Delegate)GCHandle.FromIntPtr(delegateGCHandleA).Target;
|
|
var @delegateB = (Delegate)GCHandle.FromIntPtr(delegateGCHandleB).Target;
|
|
return (@delegateA == @delegateB).ToGodotBool();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
ExceptionUtils.DebugUnhandledException(e);
|
|
return false.ToGodotBool();
|
|
}
|
|
}
|
|
|
|
[UnmanagedCallersOnly]
|
|
internal static unsafe void InvokeWithVariantArgs(IntPtr delegateGCHandle, godot_variant** args, uint argc,
|
|
godot_variant* outRet)
|
|
{
|
|
try
|
|
{
|
|
// TODO: Optimize
|
|
var @delegate = (Delegate)GCHandle.FromIntPtr(delegateGCHandle).Target;
|
|
var managedArgs = new object[argc];
|
|
|
|
var parameterInfos = @delegate!.Method.GetParameters();
|
|
var paramsLength = parameterInfos.Length;
|
|
|
|
if (argc != paramsLength)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"The delegate expects {paramsLength} arguments, but received {argc}.");
|
|
}
|
|
|
|
for (uint i = 0; i < argc; i++)
|
|
{
|
|
managedArgs[i] = Marshaling.variant_to_mono_object_of_type(
|
|
args[i], parameterInfos[i].ParameterType);
|
|
}
|
|
|
|
object invokeRet = @delegate.DynamicInvoke(managedArgs);
|
|
|
|
*outRet = Marshaling.mono_object_to_variant(invokeRet);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
ExceptionUtils.DebugPrintUnhandledException(e);
|
|
*outRet = default;
|
|
}
|
|
}
|
|
|
|
// TODO: Check if we should be using BindingFlags.DeclaredOnly (would give better reflection performance).
|
|
|
|
private enum TargetKind : uint
|
|
{
|
|
Static,
|
|
GodotObject,
|
|
CompilerGenerated
|
|
}
|
|
|
|
internal static bool TrySerializeDelegateWithGCHandle(IntPtr delegateGCHandle, Collections.Array serializedData)
|
|
=> TrySerializeDelegate((Delegate)GCHandle.FromIntPtr(delegateGCHandle).Target, serializedData);
|
|
|
|
private static bool TrySerializeDelegate(Delegate @delegate, Collections.Array serializedData)
|
|
{
|
|
if (@delegate is MulticastDelegate multicastDelegate)
|
|
{
|
|
bool someDelegatesSerialized = false;
|
|
|
|
Delegate[] invocationList = multicastDelegate.GetInvocationList();
|
|
|
|
if (invocationList.Length > 1)
|
|
{
|
|
var multiCastData = new Collections.Array();
|
|
|
|
foreach (Delegate oneDelegate in invocationList)
|
|
someDelegatesSerialized |= TrySerializeDelegate(oneDelegate, multiCastData);
|
|
|
|
if (!someDelegatesSerialized)
|
|
return false;
|
|
|
|
serializedData.Add(multiCastData);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (TrySerializeSingleDelegate(@delegate, out byte[] buffer))
|
|
{
|
|
serializedData.Add(buffer);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TrySerializeSingleDelegate(Delegate @delegate, out byte[] buffer)
|
|
{
|
|
buffer = null;
|
|
|
|
object target = @delegate.Target;
|
|
|
|
switch (target)
|
|
{
|
|
case null:
|
|
{
|
|
using (var stream = new MemoryStream())
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
writer.Write((ulong)TargetKind.Static);
|
|
|
|
SerializeType(writer, @delegate.GetType());
|
|
|
|
if (!TrySerializeMethodInfo(writer, @delegate.Method))
|
|
return false;
|
|
|
|
buffer = stream.ToArray();
|
|
return true;
|
|
}
|
|
}
|
|
// ReSharper disable once RedundantNameQualifier
|
|
case Godot.Object godotObject:
|
|
{
|
|
using (var stream = new MemoryStream())
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
writer.Write((ulong)TargetKind.GodotObject);
|
|
// ReSharper disable once RedundantCast
|
|
writer.Write((ulong)godotObject.GetInstanceId());
|
|
|
|
SerializeType(writer, @delegate.GetType());
|
|
|
|
if (!TrySerializeMethodInfo(writer, @delegate.Method))
|
|
return false;
|
|
|
|
buffer = stream.ToArray();
|
|
return true;
|
|
}
|
|
}
|
|
default:
|
|
{
|
|
Type targetType = target.GetType();
|
|
|
|
if (targetType.IsDefined(typeof(CompilerGeneratedAttribute), true))
|
|
{
|
|
// Compiler generated. Probably a closure. Try to serialize it.
|
|
|
|
using (var stream = new MemoryStream())
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
writer.Write((ulong)TargetKind.CompilerGenerated);
|
|
SerializeType(writer, targetType);
|
|
|
|
SerializeType(writer, @delegate.GetType());
|
|
|
|
if (!TrySerializeMethodInfo(writer, @delegate.Method))
|
|
return false;
|
|
|
|
FieldInfo[] fields = targetType.GetFields(BindingFlags.Instance | BindingFlags.Public);
|
|
|
|
writer.Write(fields.Length);
|
|
|
|
foreach (FieldInfo field in fields)
|
|
{
|
|
Type fieldType = field.GetType();
|
|
|
|
Variant.Type variantType = GD.TypeToVariantType(fieldType);
|
|
|
|
if (variantType == Variant.Type.Nil)
|
|
return false;
|
|
|
|
writer.Write(field.Name);
|
|
byte[] valueBuffer = GD.Var2Bytes(field.GetValue(target));
|
|
writer.Write(valueBuffer.Length);
|
|
writer.Write(valueBuffer);
|
|
}
|
|
|
|
buffer = stream.ToArray();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool TrySerializeMethodInfo(BinaryWriter writer, MethodInfo methodInfo)
|
|
{
|
|
if (methodInfo == null)
|
|
return false;
|
|
|
|
SerializeType(writer, methodInfo.DeclaringType);
|
|
|
|
writer.Write(methodInfo.Name);
|
|
|
|
int flags = 0;
|
|
|
|
if (methodInfo.IsPublic)
|
|
flags |= (int)BindingFlags.Public;
|
|
else
|
|
flags |= (int)BindingFlags.NonPublic;
|
|
|
|
if (methodInfo.IsStatic)
|
|
flags |= (int)BindingFlags.Static;
|
|
else
|
|
flags |= (int)BindingFlags.Instance;
|
|
|
|
writer.Write(flags);
|
|
|
|
Type returnType = methodInfo.ReturnType;
|
|
bool hasReturn = methodInfo.ReturnType != typeof(void);
|
|
|
|
writer.Write(hasReturn);
|
|
if (hasReturn)
|
|
SerializeType(writer, returnType);
|
|
|
|
ParameterInfo[] parameters = methodInfo.GetParameters();
|
|
|
|
writer.Write(parameters.Length);
|
|
|
|
if (parameters.Length > 0)
|
|
{
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
SerializeType(writer, parameters[i].ParameterType);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void SerializeType(BinaryWriter writer, Type type)
|
|
{
|
|
if (type == null)
|
|
{
|
|
int genericArgumentsCount = -1;
|
|
writer.Write(genericArgumentsCount);
|
|
}
|
|
else if (type.IsGenericType)
|
|
{
|
|
Type genericTypeDef = type.GetGenericTypeDefinition();
|
|
Type[] genericArgs = type.GetGenericArguments();
|
|
|
|
int genericArgumentsCount = genericArgs.Length;
|
|
writer.Write(genericArgumentsCount);
|
|
|
|
string assemblyQualifiedName = genericTypeDef.AssemblyQualifiedName;
|
|
Debug.Assert(assemblyQualifiedName != null);
|
|
writer.Write(assemblyQualifiedName);
|
|
|
|
for (int i = 0; i < genericArgs.Length; i++)
|
|
SerializeType(writer, genericArgs[i]);
|
|
}
|
|
else
|
|
{
|
|
int genericArgumentsCount = 0;
|
|
writer.Write(genericArgumentsCount);
|
|
|
|
string assemblyQualifiedName = type.AssemblyQualifiedName;
|
|
Debug.Assert(assemblyQualifiedName != null);
|
|
writer.Write(assemblyQualifiedName);
|
|
}
|
|
}
|
|
|
|
private static bool TryDeserializeDelegateWithGCHandle(Collections.Array serializedData,
|
|
out IntPtr delegateGCHandle)
|
|
{
|
|
bool res = TryDeserializeDelegate(serializedData, out Delegate @delegate);
|
|
delegateGCHandle = GCHandle.ToIntPtr(GCHandle.Alloc(@delegate));
|
|
return res;
|
|
}
|
|
|
|
private static bool TryDeserializeDelegate(Collections.Array serializedData, out Delegate @delegate)
|
|
{
|
|
if (serializedData.Count == 1)
|
|
{
|
|
object elem = serializedData[0];
|
|
|
|
if (elem is Collections.Array multiCastData)
|
|
return TryDeserializeDelegate(multiCastData, out @delegate);
|
|
|
|
return TryDeserializeSingleDelegate((byte[])elem, out @delegate);
|
|
}
|
|
|
|
@delegate = null;
|
|
|
|
var delegates = new List<Delegate>(serializedData.Count);
|
|
|
|
foreach (object elem in serializedData)
|
|
{
|
|
if (elem is Collections.Array multiCastData)
|
|
{
|
|
if (TryDeserializeDelegate(multiCastData, out Delegate oneDelegate))
|
|
delegates.Add(oneDelegate);
|
|
}
|
|
else
|
|
{
|
|
if (TryDeserializeSingleDelegate((byte[])elem, out Delegate oneDelegate))
|
|
delegates.Add(oneDelegate);
|
|
}
|
|
}
|
|
|
|
if (delegates.Count <= 0)
|
|
return false;
|
|
|
|
@delegate = delegates.Count == 1 ? delegates[0] : Delegate.Combine(delegates.ToArray());
|
|
return true;
|
|
}
|
|
|
|
private static bool TryDeserializeSingleDelegate(byte[] buffer, out Delegate @delegate)
|
|
{
|
|
@delegate = null;
|
|
|
|
using (var stream = new MemoryStream(buffer, writable: false))
|
|
using (var reader = new BinaryReader(stream))
|
|
{
|
|
var targetKind = (TargetKind)reader.ReadUInt64();
|
|
|
|
switch (targetKind)
|
|
{
|
|
case TargetKind.Static:
|
|
{
|
|
Type delegateType = DeserializeType(reader);
|
|
if (delegateType == null)
|
|
return false;
|
|
|
|
if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
|
|
return false;
|
|
|
|
@delegate = Delegate.CreateDelegate(delegateType, null, methodInfo);
|
|
return true;
|
|
}
|
|
case TargetKind.GodotObject:
|
|
{
|
|
ulong objectId = reader.ReadUInt64();
|
|
// ReSharper disable once RedundantNameQualifier
|
|
Godot.Object godotObject = GD.InstanceFromId(objectId);
|
|
if (godotObject == null)
|
|
return false;
|
|
|
|
Type delegateType = DeserializeType(reader);
|
|
if (delegateType == null)
|
|
return false;
|
|
|
|
if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
|
|
return false;
|
|
|
|
@delegate = Delegate.CreateDelegate(delegateType, godotObject, methodInfo);
|
|
return true;
|
|
}
|
|
case TargetKind.CompilerGenerated:
|
|
{
|
|
Type targetType = DeserializeType(reader);
|
|
if (targetType == null)
|
|
return false;
|
|
|
|
Type delegateType = DeserializeType(reader);
|
|
if (delegateType == null)
|
|
return false;
|
|
|
|
if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
|
|
return false;
|
|
|
|
int fieldCount = reader.ReadInt32();
|
|
|
|
object recreatedTarget = Activator.CreateInstance(targetType);
|
|
|
|
for (int i = 0; i < fieldCount; i++)
|
|
{
|
|
string name = reader.ReadString();
|
|
int valueBufferLength = reader.ReadInt32();
|
|
byte[] valueBuffer = reader.ReadBytes(valueBufferLength);
|
|
|
|
FieldInfo fieldInfo =
|
|
targetType.GetField(name, BindingFlags.Instance | BindingFlags.Public);
|
|
fieldInfo?.SetValue(recreatedTarget, GD.Bytes2Var(valueBuffer));
|
|
}
|
|
|
|
@delegate = Delegate.CreateDelegate(delegateType, recreatedTarget, methodInfo);
|
|
return true;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool TryDeserializeMethodInfo(BinaryReader reader, out MethodInfo methodInfo)
|
|
{
|
|
methodInfo = null;
|
|
|
|
Type declaringType = DeserializeType(reader);
|
|
|
|
string methodName = reader.ReadString();
|
|
|
|
int flags = reader.ReadInt32();
|
|
|
|
bool hasReturn = reader.ReadBoolean();
|
|
Type returnType = hasReturn ? DeserializeType(reader) : typeof(void);
|
|
|
|
int parametersCount = reader.ReadInt32();
|
|
|
|
if (parametersCount > 0)
|
|
{
|
|
var parameterTypes = new Type[parametersCount];
|
|
|
|
for (int i = 0; i < parametersCount; i++)
|
|
{
|
|
Type parameterType = DeserializeType(reader);
|
|
if (parameterType == null)
|
|
return false;
|
|
parameterTypes[i] = parameterType;
|
|
}
|
|
|
|
methodInfo = declaringType.GetMethod(methodName, (BindingFlags)flags, null, parameterTypes, null);
|
|
return methodInfo != null && methodInfo.ReturnType == returnType;
|
|
}
|
|
|
|
methodInfo = declaringType.GetMethod(methodName, (BindingFlags)flags);
|
|
return methodInfo != null && methodInfo.ReturnType == returnType;
|
|
}
|
|
|
|
private static Type DeserializeType(BinaryReader reader)
|
|
{
|
|
int genericArgumentsCount = reader.ReadInt32();
|
|
|
|
if (genericArgumentsCount == -1)
|
|
return null;
|
|
|
|
string assemblyQualifiedName = reader.ReadString();
|
|
var type = Type.GetType(assemblyQualifiedName);
|
|
|
|
if (type == null)
|
|
return null; // Type not found
|
|
|
|
if (genericArgumentsCount != 0)
|
|
{
|
|
var genericArgumentTypes = new Type[genericArgumentsCount];
|
|
|
|
for (int i = 0; i < genericArgumentsCount; i++)
|
|
{
|
|
Type genericArgumentType = DeserializeType(reader);
|
|
if (genericArgumentType == null)
|
|
return null;
|
|
genericArgumentTypes[i] = genericArgumentType;
|
|
}
|
|
|
|
type = type.MakeGenericType(genericArgumentTypes);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
}
|
|
}
|