/// <summary>
/// Looks for a given function name
/// </summary>
public UFunction FindFunctionChecked(FName name)
{
return(GCHelper.Find <UFunction>(Native_UObject.FindFunctionChecked(Address, ref name)));
}
/// <summary>
/// Traverses the outer chain searching for the next object of a certain type. (T must be derived from UObject)
/// </summary>
/// <param name="target">class to search for</param>
/// <returns>a pointer to the first object in this object's Outer chain which is of the correct type.</returns>
public UObject GetTypedOuter(UClass target)
{
return(GCHelper.Find(Native_UObjectBaseUtility.GetTypedOuter(Address, target == null ? IntPtr.Zero : target.Address)));
}
/// <summary>
/// Finds the most-derived class which is a parent of both TestClass and this object's class.
/// </summary>
/// <param name="testClass"></param>
/// <returns>the class to find the common base for</returns>
public UClass FindNearestCommonBaseClass(UClass testClass)
{
return(GCHelper.Find <UClass>(Native_UObjectBaseUtility.FindNearestCommonBaseClass(Address, testClass == null ? IntPtr.Zero : testClass.Address)));
}
/// <summary>
/// Return the class of the object that is being constructed
/// </summary>
public UClass GetClass()
{
return(GCHelper.Find <UClass>(Native_FObjectInitializer.GetClass(NativeObjectInitializer)));
}
public T this[int index]
{
get
{
if (!nativeArray->IsValidIndex(index))
{
throw new IndexOutOfRangeException();
}
IntPtr address = IntPtr.Add(nativeArray->Data, numBytesPerElement * index);
if (isUObject)
{
return((T)(object)GCHelper.Find(Marshal.ReadIntPtr(address)));
}
else if (isString)
{
return((T)(object)FStringMarshaler.FromPtr(address));
}
else
{
return((T)Marshal.PtrToStructure(address, typeof(T)));
}
}
set
{
if (!nativeArray->IsValidIndex(index))
{
throw new IndexOutOfRangeException();
}
IntPtr address = IntPtr.Add(nativeArray->Data, numBytesPerElement * index);
if (isUObject)
{
if (value == null)
{
Marshal.WriteIntPtr(address, IntPtr.Zero);
}
else
{
UObject obj = (UObject)(object)value;
Marshal.WriteIntPtr(address, obj.Address);
}
}
else if (isString)
{
unsafe
{
// Get the current value, clear the current value and write the new value
FScriptArray *current = (FScriptArray *)address;
current->Destroy();
string valueStr = value == null ? null : (string)(object)value;
if (!string.IsNullOrEmpty(valueStr))
{
FStringMarshaler.ToArray(address, valueStr);
}
}
}
else
{
Marshal.StructureToPtr(value, address, false);
}
}
}
public UObject GetObjectPropertyValue_InContainer(IntPtr propertyValueAddress, int arrayIndex)
{
return(GCHelper.Find(Native_UObjectPropertyBase.GetObjectPropertyValue_InContainer(Address, propertyValueAddress, arrayIndex)));
}
/// <summary>
/// Return the object that is being constructed
/// </summary>
public UObject GetObj()
{
return(GCHelper.Find(Native_FObjectInitializer.GetObj(NativeObjectInitializer)));
}
/// <summary>
/// Return the UEnum if this property is a UByteProperty with a non-null Enum
/// </summary>
/// <returns></returns>
public UEnum GetIntPropertyEnum()
{
return(GCHelper.Find <UEnum>(Native_UNumericProperty.GetIntPropertyEnum(Address)));
}
public UObject GetValuePtr(IntPtr address)
{
return(GCHelper.Find(Marshal.ReadIntPtr(address)));
}
public void GenerateCodeForGame(AssetLoadMode loadMode, bool clearAssetCache, bool skipLevels)
{
BeginGenerateModules();
string projectPath = FPaths.ProjectFilePath;
string projectName = FPaths.GetBaseFilename(projectPath);
UnrealModuleInfo module = new UnrealModuleInfo(null, projectName, projectPath);
BeginGenerateModule(module);
UClass worldClass = GCHelper.Find <UClass>(Classes.UWorld);
AssetCache assetCache = new AssetCache(this);
if (!clearAssetCache)
{
assetCache.Load();
}
List <string> assetBlacklist = LoadAssetBlacklist();
AssetLogClear();
AssetLogLine("Load assets {0}", DateTime.Now);
bool registeredCrashHandler = false;
if (Settings.CatchCrashOnAssetLoading)
{
FCoreDelegates.OnHandleSystemError.Bind(OnAssetLoadingCrash);
registeredCrashHandler = true;
}
using (FARFilter filter = new FARFilter())
{
filter.RecursiveClasses = true;
filter.ClassNames.Add(UClass.GetClass <UBlueprint>().GetFName());
filter.ClassNames.Add(UClass.GetClass <UBlueprintGeneratedClass>().GetFName());
filter.ClassNames.Add(UClass.GetClass <UUserDefinedStruct>().GetFName());
filter.ClassNames.Add(UClass.GetClass <UUserDefinedEnum>().GetFName());
if (!skipLevels && worldClass != null)
{
filter.ClassNames.Add(worldClass.GetFName());
}
List <FAssetData> assets = FAssetData.Load(filter);
foreach (FAssetData asset in assets)
{
string assetFileName, assetFileNameError;
if (!asset.TryGetFilename(out assetFileName, out assetFileNameError))
{
FMessage.Log(string.Format("FAssetData.TryGetFilename failed. ObjectPath:'{0}' reason:'{1}'",
asset.ObjectPath.ToString(), assetFileNameError));
continue;
}
bool isEngineAsset = FPaths.IsSameOrSubDirectory(FPaths.EngineContentDir, FPaths.GetPath(assetFileName));
if (loadMode != AssetLoadMode.All)
{
if ((isEngineAsset && loadMode != AssetLoadMode.Engine) ||
(!isEngineAsset && loadMode != AssetLoadMode.Game))
{
continue;
}
}
if (!assetCache.HasAssetChanged(asset, assetFileName))
{
if (Settings.LogAssetLoadingVerbose)
{
AssetLogLine("'{0}' unchanged", assetFileName);
}
continue;
}
// Log that we are loading this asset so we know which assets crash on load
AssetLog("'{0}' - ", asset.ObjectPath.ToString());
if (assetBlacklist.Contains(asset.ObjectPath.ToString()))
{
AssetLogLine("blacklisted");
continue;
}
loadingAsset = asset.ObjectPath.ToString();
UObject obj = asset.GetAsset();
loadingAsset = null;
UClass unrealClass = asset.GetClass();
if (obj == null || unrealClass == null)
{
AssetLogLine("null");
continue;
}
AssetLogLine("done");
if (unrealClass.IsChildOf <UBlueprint>())
{
UBlueprint blueprint = obj as UBlueprint;
if (blueprint != null)
{
UBlueprintGeneratedClass blueprintGeneratedClass = blueprint.GeneratedClass as UBlueprintGeneratedClass;
if (blueprintGeneratedClass != null)
{
GenerateCodeForStruct(module, blueprintGeneratedClass);
}
}
}
else if (unrealClass.IsChildOf <UBlueprintGeneratedClass>())
{
UBlueprintGeneratedClass blueprintGeneratedClass = obj as UBlueprintGeneratedClass;
if (blueprintGeneratedClass != null)
{
GenerateCodeForStruct(module, blueprintGeneratedClass);
}
}
else if (unrealClass.IsChildOf <UUserDefinedStruct>())
{
UUserDefinedStruct unrealStruct = obj as UUserDefinedStruct;
if (unrealStruct != null)
{
GenerateCodeForStruct(module, unrealStruct);
}
}
else if (unrealClass.IsChildOf <UUserDefinedEnum>())
{
UUserDefinedEnum unrealEnum = obj as UUserDefinedEnum;
if (unrealEnum != null)
{
GenerateCodeForEnum(module, unrealEnum);
}
}
else if (unrealClass.IsChildOf(worldClass))
{
TArrayUnsafeRef <UObject> levels = new TArrayUnsafeRef <UObject>(Native.Native_UWorld.GetLevels(obj.Address));
foreach (UObject level in levels)
{
using (TArrayUnsafe <UBlueprint> levelBlueprints = new TArrayUnsafe <UBlueprint>())
{
Native.Native_ULevel.GetLevelBlueprints(level.Address, levelBlueprints.Address);
foreach (UBlueprint blueprint in levelBlueprints)
{
UBlueprintGeneratedClass blueprintGeneratedClass = blueprint.GeneratedClass as UBlueprintGeneratedClass;
if (blueprintGeneratedClass != null)
{
//GenerateCodeForStruct(blueprintGeneratedClass);
}
}
}
}
}
}
}
if (registeredCrashHandler)
{
FCoreDelegates.OnHandleSystemError.Unbind(OnAssetLoadingCrash);
}
assetCache.Save();
EndGenerateModule(module);
EndGenerateModules();
}
/// <summary>
/// Returns the property representing the element of the set
/// </summary>
public UProperty GetElementProperty()
{
return(GCHelper.Find <UProperty>(elementProp));
}
/// <summary>
/// Attempts to find a currently loaded object that matches this object ID
/// </summary>
/// <returns>Found UObject, or NULL if not currently loaded</returns>
public UObject ResolveObject()
{
return(GCHelper.Find(Native_FSoftObjectPath.ResolveObject(ref this)));
}
/// <summary>
/// Attempts to load the asset.
/// </summary>
/// <returns>Loaded UObject, or null if the asset fails to load, or if the reference is not valid.</returns>
public UObject TryLoad()
{
return(GCHelper.Find(Native_FSoftObjectPath.TryLoad(ref this)));
}
public UObject GetObjectPropertyValue(IntPtr propertyValueAddress)
{
return(GCHelper.Find(Native_UObjectPropertyBase.GetObjectPropertyValue(Address, propertyValueAddress)));
}
/// <summary>
/// Returns a pointer to the UEnum of this property
/// </summary>
/// <returns></returns>
public UEnum GetEnum()
{
return(GCHelper.Find <UEnum>(Native_UEnumProperty.GetEnum(Address)));
}
/// <summary>
/// Return the archetype that this object will copy properties from later
/// </summary>
public UObject GetArchetype()
{
return(GCHelper.Find(Native_FObjectInitializer.GetArchetype(NativeObjectInitializer)));
}
/// <summary>
/// Returns the numeric property which represents the integral type of the enum.
/// </summary>
/// <returns></returns>
public UNumericProperty GetUnderlyingProperty()
{
return(GCHelper.Find <UNumericProperty>(Native_UEnumProperty.GetUnderlyingProperty(Address)));
}
/// <summary>
/// Returns the replication owner, which is the property itself, or NULL if this isn't important for replication.
/// It is relevant if the property is a net relevant and not being run in the editor
/// </summary>
/// <returns></returns>
public UProperty GetRepOwner()
{
return(GCHelper.Find <UProperty>(Native_UProperty.GetRepOwner(Address)));
}