internal static void RegisterManagedClass(IntPtr classAddress, Type type)
{
UClass existingClass;
if (classes.TryGetValue(type, out existingClass))
{
classes.Remove(type);
classesByAddress.Remove(existingClass.Address);
}
seenClasses.Remove(type);
classesByAddress[classAddress] = type;
UClass unrealClass = GCHelper.Find <UClass>(classAddress);
if (unrealClass != null)
{
classes[type] = unrealClass;
}
else
{
classesByAddress.Remove(classAddress);
}
// If this is an interface add it to UnrealInterfacePool so that we can create instances of this
// interface which are implemented in Blueprint
if (type.IsInterface)
{
UnrealInterfacePool.LoadType(type);
}
}
public override void OnWorldAdded(IntPtr world)
{
if (GetDefaultValue != null)
{
values[world] = GetDefaultValue(GCHelper.Find(world));
}
}
public bool MoveNext()
{
if (objectArrayPtr == IntPtr.Zero)
{
return(false);
}
//checkSlow(IsInAsyncLoadingThread() || int32(InternalExclusionFlags & EInternalObjectFlags::AsyncLoading));
//@todo UE4 check this for LHS on Index on consoles
currentObject = null;
while (++index < Native_FUObjectArray.GetObjectArrayNum(objectArrayPtr))
{
UObject obj = GCHelper.Find(Native_FUObjectArray.GetObjectAtIndex(objectArrayPtr, index));
if (obj != null)
{
if (!obj.HasAnyFlags(exclusionFlags) ||
(unrealClass != null && unrealClass != uobjectClass && !obj.IsA(unrealClass)) ||
obj.HasAnyInternalFlags(internalExclusionFlags))
{
continue;
}
currentObject = obj;
return(true);
}
}
return(false);
}
public WorldStaticVar(GetDefaultValueHandler getDefaultValue, params EWorldType[] worldTypes)
{
GetDefaultValue = getDefaultValue;
foreach (EWorldType worldType in worldTypes)
{
worldTypeFlags |= (1 << (int)worldType);
}
// Initialize the value for already created worlds
FWorldContext[] worldContexts = FWorldContext.GetWorldContexts();
foreach (FWorldContext worldContext in worldContexts)
{
if (worldContext.CurrentWorld != IntPtr.Zero)
{
int worldType = (1 << (int)worldContext.WorldType);
if ((worldTypeFlags & worldType) == worldType)
{
UObject world = GCHelper.Find(worldContext.CurrentWorld);
if (world != null)
{
Set(world, GetDefaultValue(world));
}
}
}
}
}
public T GetSubsystem <T>() where T : USubsystem
{
UClass uclass = UClass.GetClass(typeof(T));
IntPtr system = Native_FSubsystemCollection.GetSubsystem(this.Address, uclass.Address);
return(GCHelper.Find <T>(system));
}
internal static void OnReload()
{
EngineLoop.OnReload();
GCHelper.OnReload();
try
{
if (ReloadBegin != null)
{
ReloadBegin();
}
}
catch (Exception e)
{
FMessage.Log(ELogVerbosity.Error, "HotReload.ReloadBegin failed. Exception: " + Environment.NewLine + e);
}
try
{
if (ReloadEnd != null)
{
ReloadEnd();
}
}
catch (Exception e)
{
FMessage.Log(ELogVerbosity.Error, "HotReload.ReloadEnd failed. Exception: " + Environment.NewLine + e);
}
Data = null;
IsReloading = false;
}
internal static void Load()
{
classes.Clear();
classesByAddress.Clear();
seenClasses.Clear();
// Use two passes so that classesByAddress has all available types which are needed when
// calling GCHelper.Find() in the second pass
// First pass to fill up classesByAddress collection
foreach (KeyValuePair <Type, UMetaPathAttribute> nativeType in UnrealTypes.Native)
{
Type type = nativeType.Key;
UMetaPathAttribute attribute = nativeType.Value;
if (type.IsSameOrSubclassOf(typeof(UObject)) || type.IsInterface)
{
IntPtr classAddress = GetClassAddress(attribute.Path);
if (classAddress != IntPtr.Zero)
{
classesByAddress[classAddress] = type;
}
}
}
// It should now be safe to access GCHelper (which is required by the second pass to fill
// in the classes collection with the managed UClass objects)
GCHelper.Available = true;
int unknownCount = 0;
// Second pass fill up classes collection
foreach (KeyValuePair <IntPtr, Type> classByAddress in classesByAddress)
{
IntPtr classAddress = classByAddress.Key;
Type type = classByAddress.Value;
UClass unrealClass = GCHelper.Find <UClass>(classAddress);
if (unrealClass != null)
{
classes[type] = unrealClass;
}
else
{
unknownCount++;
}
}
if (unknownCount > 0)
{
// sync classes/classByAddress if some failed to add to the classes collection
foreach (KeyValuePair <IntPtr, Type> classByAddress in new Dictionary <IntPtr, Type>(classesByAddress))
{
if (!classes.ContainsKey(classByAddress.Value))
{
classesByAddress.Remove(classByAddress.Key);
}
}
}
}
/// <summary>
/// Find an existing package by name or create it if it doesn't exist
/// </summary>
/// <param name="outer">The Outer object to search inside</param>
/// <param name="packageName"></param>
/// <returns>The existing package or a newly created one</returns>
public static UPackage CreatePackage(ObjectOuter outer, string packageName)
{
using (FStringUnsafe packageNameUnsafe = new FStringUnsafe(packageName))
{
return(GCHelper.Find <UPackage>(Native_UObjectGlobals.CreatePackage(outer.Address, ref packageNameUnsafe.Array)));
}
}
/// <summary>
/// Finds the common base class that parents the array of classes passed in.
/// </summary>
/// <param name="inClasses">the array of classes to find the common base for</param>
/// <returns>the common base class or NULL</returns>
public static UClass FindCommonBase(UClass[] inClasses)
{
using (TArrayUnsafe <UClass> inClassesUnsafe = new TArrayUnsafe <UClass>())
{
inClassesUnsafe.AddRange(inClasses);
return(GCHelper.Find <UClass>(Native_UClass.FindCommonBaseMany(inClassesUnsafe.Address)));
}
}
/// <summary>
/// Gets the UClass for the given UObject address
/// </summary>
/// <param name="objectAddress">The address of the UObject</param>
/// <returns>The UClass for the given UObject address</returns>
public static UClass GetClass(IntPtr objectAddress)
{
if (objectAddress == IntPtr.Zero)
{
return(null);
}
return(GCHelper.Find <UClass>(Native_UObjectBase.GetClass(objectAddress)));
}
/// <summary>
/// Create a component or subobject only to be used with the editor.
/// </summary>
/// <param name="outer">outer to construct the subobject in</param>
/// <param name="subobjectName">name of the new component</param>
/// <param name="returnType">type of the new component</param>
/// <param name="transient">true if the component is being assigned to a transient property</param>
/// <returns></returns>
public UObject CreateEditorOnlyDefaultSubobject(UObject outer, FName subobjectName, UClass returnType, bool transient)
{
return(GCHelper.Find(Native_FObjectInitializer.CreateEditorOnlyDefaultSubobject(NativeObjectInitializer,
outer == null ? IntPtr.Zero : outer.Address,
ref subobjectName,
returnType == null ? IntPtr.Zero : returnType.Address,
transient)));
}
/// <summary>
/// Loads a package and all contained objects that match context flags.
/// </summary>
/// <param name="outer">Package to load new package into (usually NULL or ULevel->GetOuter())</param>
/// <param name="longPackageName">Long package name to load</param>
/// <param name="loadFlags">Flags controlling loading behavior</param>
/// <returns>Loaded package if successful, NULL otherwise</returns>
public static UPackage LoadPackage(UPackage outer, string longPackageName, ELoadFlags loadFlags)
{
using (FStringUnsafe longPackageNameUnsafe = new FStringUnsafe(longPackageName))
{
return(GCHelper.Find <UPackage>(Native_UObjectGlobals.LoadPackage(
outer == null ? IntPtr.Zero : outer.Address, ref longPackageNameUnsafe.Array, loadFlags)));
}
}
public static unsafe void HackVTable(UObject obj)
{
// This will swap out the vtable entry and store the old one in our managed UClass
if (!Native_UObjectBaseUtility.IsA(obj.Address, Runtime.Classes.UClass))
{
UClass unrealClass = obj.GetClass();
if (unrealClass.VTableOriginalFunctions == null)
{
IntPtr *vtable = *(IntPtr **)obj.Address;
unrealClass.VTableOriginalFunctions = new Dictionary <int, UClass.VTableOriginalFunc>();
foreach (FunctionRedirect redirect in vtableRedirects)
{
if (!Native_UObjectBaseUtility.IsA(obj.Address, redirect.Class))
{
continue;
}
IntPtr originalFunctionAddress = vtable[redirect.VTableIndex];
if (originalFunctionAddress != redirect.NativeCallback)
{
IntPtr originalOwnerClassAddress = FindOriginalVTableOwner(
redirect.Class, unrealClass.Address, originalFunctionAddress, redirect.VTableIndex);
if (originalOwnerClassAddress != unrealClass.Address)
{
UClass originalOwnerClass = GCHelper.Find <UClass>(originalOwnerClassAddress);
if (originalOwnerClass.VTableOriginalFunctions == null)
{
HackVTable(originalOwnerClass.GetDefaultObject());
}
}
IntPtr pageAlignedPtr = FMemory.PageAlignPointer((IntPtr)(&vtable[redirect.VTableIndex]));
FMemory.PageProtect(pageAlignedPtr, (IntPtr)IntPtr.Size, true, true);
*(&vtable[redirect.VTableIndex]) = redirect.NativeCallback;
}
else
{
// The VTable has already been swapped out. Find the original function address.
UClass superClass = unrealClass;
while ((superClass = superClass.GetSuperClass()) != null && superClass.VTableOriginalFunctions == null)
{
}
Debug.Assert(superClass != null && superClass.VTableOriginalFunctions != null &&
superClass.VTableOriginalFunctions.ContainsKey(redirect.VTableIndex));
originalFunctionAddress = superClass.VTableOriginalFunctions[redirect.VTableIndex].FuncAddress;
}
unrealClass.VTableOriginalFunctions.Add(redirect.VTableIndex, new UClass.VTableOriginalFunc(originalFunctionAddress));
}
}
}
}
public UObject[] GetObjects()
{
UObject[] result = new UObject[objArray.Count];
for (int i = 0; i < objArray.Count; i++)
{
result[i] = GCHelper.Find(objArray[i]);
}
return(result);
}
private void NativeCallback(IntPtr objectBeingModified)
{
var evnt = managed.Delegate;
if (evnt != null)
{
evnt(GCHelper.Find(objectBeingModified));
}
}
private void NativeCallback(IntPtr savedObject)
{
var evnt = managed.Delegate;
if (evnt != null)
{
evnt(GCHelper.Find(savedObject));
}
}
private void NativeCallback(IntPtr loadedWorld)
{
var evnt = managed.Delegate;
if (evnt != null)
{
evnt(GCHelper.Find(loadedWorld));
}
}
/// <summary>
/// Load a class object.
/// </summary>
public static UClass LoadClass(UClass baseClass, ObjectOuter outer, string name, string filename = null, ELoadFlags loadFlags = ELoadFlags.None)
{
using (FStringUnsafe nameUnsafe = new FStringUnsafe(name))
using (FStringUnsafe filenameUnsafe = new FStringUnsafe(filename))
{
return(GCHelper.Find <UClass>(Native_UObjectGlobals.StaticLoadClass(
baseClass.Address, outer.Address, ref nameUnsafe.Array, ref filenameUnsafe.Array, loadFlags, IntPtr.Zero)));
}
}
private void ConsoleCommandWithWorldDelegate(IntPtr world)
{
var command = Command as FConsoleCommandWithWorldDelegate;
if (command != null)
{
command(GCHelper.Find(world));
}
}
private static void OnActorEndPlay(IntPtr address, byte endPlayReason)
{
UObject obj = GCHelper.Find(address);
IntPtr original = actorEndPlay.GetOriginal(obj);
Native_VTableHacks.CallOriginal_ActorEndPlay(original, address, endPlayReason);
obj.EndPlayInternal(endPlayReason);
}
private static void OnActorComponentBeginPlay(IntPtr address)
{
UObject obj = GCHelper.Find(address);
IntPtr original = actorComponentBeginPlay.GetOriginal(obj);
Native_VTableHacks.CallOriginal_ActorComponentBeginPlay(original, address);
obj.BeginPlayInternal();
}
/// <summary>
/// Gets the UEnum for the given path (e.g. "/Script/CoreUObject.ESearchCase")
/// </summary>
/// <param name="path">The path of the UEnum</param>
/// <returns>The UEnum for the given path</returns>
public static UEnum GetEnum(string path)
{
IntPtr address = GetEnumAddress(path);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UEnum>(address));
}
return(null);
}
private static void OnSetupPlayerInputComponent(IntPtr address, IntPtr inputComponentAddress)
{
UObject obj = GCHelper.Find(address);
IntPtr original = setupPlayerInput.GetOriginal(obj);
Native_VTableHacks.CallOriginal_SetupPlayerInputComponent(original, address, inputComponentAddress);
obj.SetupPlayerInputComponent(inputComponentAddress);
}
/// <summary>
/// Gets the UClass (interface) for the given interface type (defined in managed code)
/// </summary>
/// <param name="type">The interface type</param>
/// <returns>The UClass (interface) for the given type</returns>
public static UClass GetInterface(Type type)
{
IntPtr address = GetInterfaceAddress(type);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UClass>(address));
}
return(null);
}
/// <summary>
/// Loads the UScriptStruct for the given path (e.g. "/Script/CoreUObject.Guid")
/// </summary>
/// <param name="path">The path of the UScriptStruct</param>
/// <returns>The UScriptStruct for the given path</returns>
public static UScriptStruct LoadStruct(string path)
{
IntPtr address = LoadStructAddress(path);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UScriptStruct>(address));
}
return(null);
}
/// <summary>
/// Gets the UFunction for the given delegate type (defined in managed code)
/// </summary>
/// <param name="type">The type of the delegate</param>
/// <returns>The UFunction for the given type</returns>
public static UFunction GetDelegateSignature(Type type)
{
IntPtr address = GetDelegateSignatureAddress(type);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UFunction>(address));
}
return(null);
}
/// <summary>
/// Gets the UScriptStruct for the given struct type (defined in managed code)
/// </summary>
/// <param name="type">The type of the struct</param>
/// <returns>The UScriptStruct for the given type</returns>
public static UScriptStruct GetStruct(Type type)
{
IntPtr address = GetStructAddress(type);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UScriptStruct>(address));
}
return(null);
}
/// <summary>
/// Gets the UEnum for the given enum type (defined in managed code)
/// </summary>
/// <param name="type">The type of the enum</param>
/// <returns>The UEnum for the given type</returns>
public static UEnum GetEnum(Type type)
{
IntPtr address = GetEnumAddress(type);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UEnum>(address));
}
return(null);
}
/// <summary>
/// Gets the UFunction for the given path (e.g. "/Script/Engine.Actor:SetOwner")
/// </summary>
/// <param name="path">The path of the UFunction</param>
/// <returns>The UFunction for the given path</returns>
public static UFunction GetFunction(string path)
{
IntPtr address = GetFunctionAddress(path);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UFunction>(address));
}
return(null);
}
/// <summary>
/// Gets the UProperty for the given path (e.g. "/Script/Engine.Actor:bReplicates")
/// </summary>
/// <param name="path">The path of the UProperty</param>
/// <returns>The UProperty for the given path</returns>
public static UProperty GetProperty(string path)
{
IntPtr address = GetPropertyAddress(path);
if (address != IntPtr.Zero)
{
return(GCHelper.Find <UProperty>(address));
}
return(null);
}
