static FEditorElement()
{
if (UnrealTypes.CanLazyLoadNativeType(typeof(FEditorElement)))
{
LoadNativeType();
}
UnrealTypes.OnCCtorCalled(typeof(FEditorElement));
}
static FMaterialQualityOverrides()
{
if (UnrealTypes.CanLazyLoadNativeType(typeof(FMaterialQualityOverrides)))
{
LoadNativeType();
}
UnrealTypes.OnCCtorCalled(typeof(FMaterialQualityOverrides));
}
static UShaderPlatformQualitySettings()
{
if (UnrealTypes.CanLazyLoadNativeType(typeof(UShaderPlatformQualitySettings)))
{
LoadNativeType();
}
UnrealTypes.OnCCtorCalled(typeof(UShaderPlatformQualitySettings));
}
static FTickFunction()
{
//if (UnrealTypes.CanLazyLoadNativeType(typeof(FTickFunction)))
{
LoadNativeType();
}
UnrealTypes.OnCCtorCalled(typeof(FTickFunction));
}
static FDebugFloatHistory()
{
if (UnrealTypes.CanLazyLoadNativeType(typeof(FDebugFloatHistory)))
{
LoadNativeType();
}
UnrealTypes.OnCCtorCalled(typeof(FDebugFloatHistory));
}
protected internal override void DeserializeProperty(UnrealBinaryReader reader)
{
if (_structName == null || !UnrealTypes.HasPropertyName(_structName))
{
Value = reader.ReadProperties();
}
else
{
UProperty property = UnrealTypes.GetPropertyByName(_structName);
property.Deserialize(reader);
Value = property;
}
}
private static void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
{
Assembly currentAssembly = typeof(NativeFunctions).Assembly;
Assembly assembly = args.LoadedAssembly;
AssemblyName[] referencedAssemblies = assembly.GetReferencedAssemblies();
foreach (AssemblyName assemblyName in referencedAssemblies)
{
if (assembly.FullName == currentAssembly.FullName)
{
// This is an unreal assembly. Load the unreal types.
UnrealTypes.Load(assembly);
UClass.Load(assembly);
break;
}
}
}
protected internal override void DeserializeProperty(UnrealBinaryReader reader)
{
List <UProperty> items = new List <UProperty>();
int count = reader.ReadInt32();
string innerTypeName = null;
if (_innerType == "StructProperty")
{
string settingName = reader.ReadFString();
string typeName = reader.ReadFString();
UProperty property = UnrealTypes.GetPropertyByName(_innerType);
property.DeserializeTypeInfo(reader);
innerTypeName = property.TypeName;
if (property is FStructProperty structProperty)
{
if (UnrealTypes.HasPropertyName(structProperty._structName))
{
innerTypeName = structProperty._structName;
}
}
}
for (int i = 0; i < count; i++)
{
UProperty arrayType = UnrealTypes.GetPropertyByName(innerTypeName ?? _innerType);
arrayType.DeserializeProperty(reader);
arrayType.ArrayIndex = i;
items.Add(arrayType);
}
Value = items;
}
protected internal override void DeserializeProperty(UnrealBinaryReader reader)
{
List <UProperty> items = new List <UProperty>();
NumKeysToRemove = reader.ReadInt32();
int count = reader.ReadInt32();
for (int i = 0; i < NumKeysToRemove; i++)
{
UProperty property = UnrealTypes.GetPropertyByName(_innerType);
property.DeserializeProperty(reader);
}
for (int i = 0; i < count; i++)
{
UProperty property = UnrealTypes.GetPropertyByName(_innerType);
property.DeserializeProperty(reader);
items.Add(property);
}
Value = items;
}
private static void OnNativeFunctionsRegistered()
{
bool reloading = HotReload.IsReloading;
HotReload.MinimalReload = Native_SharpHotReloadUtils.Get_MinimalHotReload();
FMessage.Log("Runtime: " + SharedRuntimeState.GetRuntimeInfo(false));
// HACK: Removing EPackageFlags.EditorOnly on the USharp package so that C# classes aren't tagged as
// EObjectMark.EditorOnly. The correct thing to do would be to seperate USharp into seperate
// Editor/Runtime modules.
IntPtr package = NativeReflection.FindPackage(IntPtr.Zero, "/Script/USharp");
if (package != IntPtr.Zero)
{
Native_UPackage.ClearPackageFlags(package, EPackageFlags.EditorOnly);
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.UnrealTypes_Load))
{
UnrealTypes.Load();
}
if (HotReload.IsReloading)
{
HotReload.OnPreReloadBegin();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.UnrealTypes_LoadNative))
{
// Load the underlying native type info for generated types (class address/properties/functions/offsets)
UnrealTypes.LoadNative();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.UClass_Load))
{
// Load native classes
UClass.Load();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.NativeFunctions_GenerateAndCompileMissingAssemblies))
{
// Update the C# game project props file
ProjectProps.Update();
// Prompt to compile the C# engine wrapper code / C# game code (if it isn't already compiled)
GenerateAndCompileMissingAssemblies();
}
// If any assemblies are loaded make sure to load their unreal types
if (!AssemblyContext.IsCoreCLR || CurrentAssemblyContext.Reference.IsInvalid)
{
// .NET Core should resolve with AssemblyLoadContext.Resolving (unless the contexts aren't set up)
CurrentAssemblyContext.AssemblyResolve += CurrentDomain_AssemblyResolve;
}
CurrentAssemblyContext.AssemblyLoad += OnAssemblyLoad;
CurrentAssemblyContext.Resolving += CurrentAssemblyContext_Resolving;
using (var timing = HotReload.Timing.Create(HotReload.Timing.NativeFunctions_LoadAssemblies))
{
// Load managed assemblies (game assembly, and any others which may need loading)
LoadAssemblies();
}
if (HotReload.IsReloading)
{
HotReload.OnPreReloadEnd();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.ManagedUnrealModuleInfo_Load))
{
// Load managed module infos
ManagedUnrealModuleInfo.Load();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.ManagedUnrealTypes_Load))
{
// Load / register managed unreal types
ManagedUnrealTypes.Load();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.HotReload_OnReload))
{
// Let HotReload handle reloading if this is a reload
if (HotReload.IsReloading)
{
HotReload.OnReload();
}
}
// Clear the hot-reload data store if it isn't cleared already
if (HotReload.Data != null)
{
HotReload.Data.Close();
HotReload.Data = null;
}
if (FBuild.WithEditor && reloading)
{
using (var timing = HotReload.Timing.Create(HotReload.Timing.UObject_CollectGarbage))
{
// If we are hotreloading collect garbage to clean up trashed types / reinstanced objects
UObject.CollectGarbage(GCHelper.GarbageCollectionKeepFlags, true);
}
if (!ManagedUnrealTypes.SkipBroadcastHotReload)
{
using (var timing = HotReload.Timing.Create(HotReload.Timing.SharpHotReloadUtils_BroadcastOnHotReload))
{
// Broadcast the native OnHotReload (if we don't do this we would need to reimplement various
// handlers to ensure correct reloading. One example is FBlueprintActionDatabase::ReloadAll
// which needs to be called otherwise the action database will hold onto our old class members
// and would produce erros when opening blueprints).
// true will show the C++ "Hot Reload Complete!" notification (are there any other differences?)
//Native_SharpHotReloadUtils.BroadcastOnHotReload(true);
// The notification rendering gets messed up the longer hotreload takes. Wait 1 frame to ensure
// that the notification gets fully rendered (though the audio still seems to mess up)
Coroutine.StartCoroutine(null, DeferBroadcastHotReload());
}
}
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.GC_Collect))
{
// We likely created a bunch of garbage, best to clean it up now.
GC.Collect();
}
}
private static void OnNativeFunctionsRegistered()
{
bool reloading = HotReload.IsReloading;
HotReload.MinimalReload = Native_SharpHotReloadUtils.Get_MinimalHotReload();
// HACK: Removing EPackageFlags.EditorOnly on the USharp package so that C# classes aren't tagged as
// EObjectMark.EditorOnly. The correct thing to do would be to seperate USharp into seperate
// Editor/Runtime modules.
IntPtr package = NativeReflection.FindPackage(IntPtr.Zero, "/Script/USharp");
if (package != IntPtr.Zero)
{
Native_UPackage.ClearPackageFlags(package, EPackageFlags.EditorOnly);
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.NativeFunctions_LoadAssemblies))
{
// Load managed assemblies (game assembly, and any others which may need loading)
LoadAssemblies();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.UnrealTypes_Load))
{
UnrealTypes.Load();
}
if (HotReload.IsReloading)
{
HotReload.OnPreReloadBegin();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.UnrealTypes_LoadNative))
{
// Load the underlying native type info for generated types (class address/properties/functions/offsets)
UnrealTypes.LoadNative();
}
// If any assemblies are loaded after this point make sure to load their unreal types
AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
using (var timing = HotReload.Timing.Create(HotReload.Timing.UClass_Load))
{
// Load native classes
UClass.Load();
}
if (HotReload.IsReloading)
{
HotReload.OnPreReloadEnd();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.ManagedUnrealModuleInfo_Load))
{
// Load managed module infos
ManagedUnrealModuleInfo.Load();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.ManagedUnrealTypes_Load))
{
// Load / register managed unreal types
ManagedUnrealTypes.Load();
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.HotReload_OnReload))
{
// Let HotReload handle reloading if this is a reload
if (HotReload.IsReloading)
{
HotReload.OnReload();
}
}
// Clear the hot-reload data store if it isn't cleared already
if (HotReload.Data != null)
{
HotReload.Data.Close();
HotReload.Data = null;
}
if (FBuild.WithEditor && reloading)
{
using (var timing = HotReload.Timing.Create(HotReload.Timing.UObject_CollectGarbage))
{
// If we are hotreloading collect garbage to clean up trashed types / reinstanced objects
UObject.CollectGarbage(GCHelper.GarbageCollectionKeepFlags, true);
}
if (!ManagedUnrealTypes.SkipBroadcastHotReload)
{
using (var timing = HotReload.Timing.Create(HotReload.Timing.SharpHotReloadUtils_BroadcastOnHotReload))
{
// Broadcast the native OnHotReload (if we don't do this we would need to reimplement various
// handlers to ensure correct reloading. One example is FBlueprintActionDatabase::ReloadAll
// which needs to be called otherwise the action database will hold onto our old class members
// and would produce erros when opening blueprints).
// true will show the C++ "Hot Reload Complete!" notification (are there any other differences?)
Native_SharpHotReloadUtils.BroadcastOnHotReload(true);
}
}
}
using (var timing = HotReload.Timing.Create(HotReload.Timing.GC_Collect))
{
// We likely created a bunch of garbage, best to clean it up now.
GC.Collect();
}
}
