internal static void OnUnload()
{
Debug.Assert(FThreading.IsInGameThread(), "Load/hotreload should be on the game thread");
//if (!FThreading.IsInGameThread())
//{
// FThreading.RunUnloader(delegate { OnUnload(); });
// return;
//}
Data = new DataStore();
IsUnloading = true;
try
{
if (UnloadBegin != null)
{
UnloadBegin();
}
}
catch (Exception e)
{
FMessage.Log(ELogVerbosity.Error, "HotReload.UnloadBegin failed. Exception: " + Environment.NewLine + e);
}
Engine.FUSharpLatentAction.OnUnload();
Engine.ManagedLatentCallbackHelper.UnregisterCallbacks();
StaticVarManager.OnUnload();
EngineLoop.OnUnload();
FThreading.OnUnload();
FTicker.OnUnload();
IConsoleManager.OnUnload();
ManagedUnrealTypes.OnUnload();
GCHelper.OnUnload();
UnbindNativeDelegates();
IsUnloaded = true;
try
{
if (UnloadEnd != null)
{
UnloadEnd();
}
}
catch (Exception e)
{
FMessage.Log(ELogVerbosity.Error, "HotReload.UnloadEnd failed. Exception: " + Environment.NewLine + e);
}
}
/// <summary>
/// Gets the address of the UEnum for the given enum type
/// </summary>
/// <param name="type">The type of the enum</param>
/// <returns>The address of the UEnum for the given type</returns>
public static IntPtr GetEnumAddress(Type type)
{
UUnrealTypePathAttribute pathAttribute = UnrealTypes.GetPathAttribute(type);
if (pathAttribute != null)
{
if (pathAttribute.IsManagedType)
{
return(ManagedUnrealTypes.GetEnumAddress(type));
}
else
{
return(GetEnumAddress(pathAttribute.Path));
}
}
return(IntPtr.Zero);
}
/// <summary>
/// Gets the address of the UFunction for the given delegate type
/// </summary>
/// <param name="type">The type of the delegate</param>
/// <returns>The address of the UFunction for the given type</returns>
public static IntPtr GetDelegateSignatureAddress(Type type)
{
UUnrealTypePathAttribute pathAttribute = UnrealTypes.GetPathAttribute(type);
if (pathAttribute != null)
{
if (pathAttribute.IsManagedType)
{
// TODO: Support dynamic loading of managed types
return(ManagedUnrealTypes.GetDelegateSignatureAddress(type));
}
else
{
return(GetFunctionAddress(pathAttribute.Path));
}
}
return(IntPtr.Zero);
}
/// <summary>
/// Loads the address of the UScriptStruct for the given struct type
/// </summary>
/// <param name="type">The type of the struct</param>
/// <returns>The address of the UScriptStruct for the given type</returns>
public static IntPtr LoadStructAddress(Type type)
{
UUnrealTypePathAttribute pathAttribute = UnrealTypes.GetPathAttribute(type);
if (pathAttribute != null)
{
if (pathAttribute.IsManagedType)
{
// TODO: Support dynamic loading of managed types
return(ManagedUnrealTypes.GetStructAddress(type));
}
else
{
return(LoadStructAddress(pathAttribute.Path));
}
}
return(IntPtr.Zero);
}
/// <summary>
/// Gets the UClass address for the given UObject derived type
/// </summary>
/// <param name="type">The UObject derived type</param>
/// <returns>The address of the UClass for the given type</returns>
public static IntPtr GetClassAddress(Type type)
{
UUnrealTypePathAttribute pathAttribute = UnrealTypes.GetPathAttribute(type);
if (pathAttribute != null)
{
if (pathAttribute.IsManagedType)
{
return(ManagedUnrealTypes.GetClassAddress(type));
}
else
{
UClass unrealClass = GetClass(type);
if (unrealClass != null)
{
return(unrealClass.Address);
}
}
}
return(IntPtr.Zero);
}
private void Constructor(IntPtr objectInitializerPtr)
{
ManagedUnrealTypes.ClassConstructor(this, objectInitializerPtr);
}
/// <summary>
/// Returns true if the given managed type can lazily load properties/offsets/functions when the type is first
/// accessed rather than when USharp is first initialized.
/// </summary>
public static bool CanLazyLoadManagedType(Type type)
{
return(LazyLoadingEnabled && gatheredUnrealTypes && ManagedUnrealTypes.IsTypeRegistered(type));
}
private IntPtr CreateProperty(IntPtr outer, Type type, string propertyName, EPropertyType propertyType,
EPropertyType innerPropertyType1, EPropertyType innerPropertyType2)
{
propertyType = ManagedUnrealTypes.GetPropertyType(type, propertyType);
IntPtr propertyClass = ManagedUnrealTypes.GetPropertyClass(propertyType);
if (propertyClass == IntPtr.Zero)
{
return(IntPtr.Zero);
}
EObjectFlags objectFlags = EObjectFlags.Public | EObjectFlags.Transient | EObjectFlags.MarkAsNative;
IntPtr property = NativeReflection.NewObject(outer, propertyClass, new FName(propertyName), objectFlags);
Native_UProperty.SetPropertyFlags(property, EPropertyFlags.BlueprintVisible | EPropertyFlags.BlueprintAssignable | EPropertyFlags.Edit);
// Set type specific information
switch (propertyType)
{
case EPropertyType.Array:
if (!firstRun)
{
Native_UArrayProperty.Set_Inner(property,
CreateProperty(property, typeof(int), propertyName, innerPropertyType1));
}
else
{
Native_UArrayProperty.Set_Inner(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
}
break;
case EPropertyType.Set:
Native_USetProperty.Set_ElementProp(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
break;
case EPropertyType.Map:
Native_UMapProperty.Set_KeyProp(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
Native_UMapProperty.Set_ValueProp(property,
CreateProperty(property, type.GenericTypeArguments[1], propertyName, innerPropertyType2));
break;
case EPropertyType.Class:
Native_UClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.Object:
var v1 = ManagedUnrealTypes.GetStaticClass(type);
var v2 = ManagedUnrealTypes.GetStaticClass(typeof(UObject));
Native_UObjectPropertyBase.SetPropertyClass(property, v1 == IntPtr.Zero ? v2 : v1);
break;
case EPropertyType.LazyObject:
case EPropertyType.WeakObject:
case EPropertyType.SoftObject:
Native_UObjectPropertyBase.SetPropertyClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.SoftClass:
Native_USoftClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.Enum:
Native_UEnumProperty.SetEnum(property, ManagedUnrealTypes.GetEnum(type));
break;
case EPropertyType.Delegate:
//Native_UDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
break;
case EPropertyType.MulticastDelegate:
//Native_UMulticastDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
break;
}
Native_UField.AddCppProperty(outer, property);
return(property);
}