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