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 unsafe void SetDotNetRuntime(string[] args)
{
// It's probably possible to dynamically load runtimes by adding a function to SharedRuntimeState (and slightly modifying
// the current load checks inside of CSharpLoader::Load)
const string enableMoreRuntimesStr =
"Only one runtime has been loaded. Modify /USharp/Binaries/Managed/Runtimes/DotNetRuntime.txt to add more runtimes and then reopen the editor.";
if (args != null && args.Length > 0)
{
bool handled = true;
switch (args[0].ToLower())
{
case "diag":
{
// Diagnostics...
FMessage.Log("============================================================================================");
FMessage.Log("Loaded modules in " + SharedRuntimeState.CurrentRuntime + ":");
foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
FMessage.Log(assembly.FullName);
}
// Also print out the loaded AppDomain instances when under the .NET Framework (CLR)
if (AssemblyContext.IsCLR)
{
FMessage.Log("================ Domains:");
string[] appDomains = AppDomainDiagnostic.GetNames();
if (appDomains != null)
{
foreach (string appDomain in appDomains)
{
FMessage.Log(appDomain);
}
}
}
}
break;
case "reload":
{
SharedRuntimeState.Instance->Reload = true;
}
break;
default:
handled = false;
break;
}
if (handled)
{
return;
}
if (SharedRuntimeState.HaveMultipleRuntimesLoaded())
{
EDotNetRuntime runtime = EDotNetRuntime.None;
switch (args[0].ToLower())
{
case "mono":
runtime = EDotNetRuntime.Mono;
break;
case "clr":
runtime = EDotNetRuntime.CLR;
break;
case "coreclr":
runtime = EDotNetRuntime.CoreCLR;
break;
}
if (runtime == EDotNetRuntime.None)
{
FMessage.Log("Unknown runtime '" + args[0] + "'. Current runtime: " + SharedRuntimeState.GetRuntimeInfo(true));
}
else if (!SharedRuntimeState.IsRuntimeLoaded(runtime))
{
FMessage.Log(runtime + " isn't loaded. Current runtime: " + SharedRuntimeState.GetRuntimeInfo(true));
}
else if (SharedRuntimeState.Instance->NextRuntime != EDotNetRuntime.None)
{
FMessage.Log("Runtime change already queued (" + SharedRuntimeState.Instance->NextRuntime.ToString() + ")");
}
else if (SharedRuntimeState.Instance->Reload)
{
FMessage.Log("The active runtime is currently reloading (" + SharedRuntimeState.Instance->ActiveRuntime + ")");
}
else if (SharedRuntimeState.Instance->ActiveRuntime == runtime)
{
FMessage.Log(runtime.ToString() + " is already the active runtime");
}
else
{
SharedRuntimeState.Instance->RuntimeCounter++;
SharedRuntimeState.Instance->NextRuntime = runtime;
FMessage.Log("Changing runtime to " + runtime.ToString() + "...");
}
}
else
{
FMessage.Log(ELogVerbosity.Error, enableMoreRuntimesStr);
FMessage.Log("Runtime: " + SharedRuntimeState.GetRuntimeInfo(true));
}
}
else
{
if (!SharedRuntimeState.HaveMultipleRuntimesLoaded())
{
FMessage.Log(enableMoreRuntimesStr);
}
FMessage.Log("Runtime: " + SharedRuntimeState.GetRuntimeInfo(true));
}
}