public void Execute(string[] args, UObject world, IntPtr outputDevice)
{
using (TArrayUnsafe <string> argsUnsafe = new TArrayUnsafe <string>())
{
argsUnsafe.AddRange(args);
Native_IConsoleCommand.Execute(Address, argsUnsafe.Address, world == null ? IntPtr.Zero : world.Address, outputDevice);
}
}
/// <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)));
}
}
private static void SetAllMetaData(IntPtr obj, ManagedUnrealReflectionBase field, UMeta.Target target)
{
if (!FBuild.WithEditor || !metaDataEnabled || field == null || string.IsNullOrEmpty(field.Path))
{
return;
}
IntPtr outermost = Native_UObjectBaseUtility.GetOutermost(obj);
IntPtr metadata = outermost == IntPtr.Zero ? IntPtr.Zero : Native_UPackage.GetMetaData(outermost);
if (metadata == IntPtr.Zero)
{
return;
}
Dictionary <FName, string> values = null;
if (!metaDataMap.TryGetValue(field.Path.ToLower(), out values))
{
values = new Dictionary <FName, string>();
}
switch (target)
{
// Class / interface
case UMeta.Target.Class:
case UMeta.Target.Interface:
// See GetMetadataKeyword (Engine\Source\Programs\UnrealHeaderTool\Private\BaseParser.cpp)
// "NotBlueprintable" removes "NotBlueprintable" and adds "IsBlueprintBase=false"
// "Blueprintable" and adds "IsBlueprintBase=true"
// "BlueprintInternalUseOnly" adds "BlueprintType"
if (!values.ContainsKey(UMeta.GetKeyName(MDClass.IsBlueprintBase)))
{
if (values.ContainsKey(UMeta.GetKeyName(MDClass.Blueprintable)))
{
values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "true";
}
else if (values.ContainsKey(UMeta.GetKeyName(MDClass.NotBlueprintable)))
{
values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "false";
}
}
MetaDataMergeClassCategories(metadata, obj, values);
break;
}
SetMetaDataBlueprintability(values, target, field as ManagedUnrealTypeInfo);
using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>())
using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>())
{
keysUnsafe.AddRange(values.Keys.ToArray());
valuesUnsafe.AddRange(values.Values.ToArray());
Native_UMetaData.SetObjectValues(metadata, obj, keysUnsafe.Address, valuesUnsafe.Address);
}
}
/// <summary>
/// Sets the array of enums.
/// </summary>
/// <param name="names">List of enum names.</param>
/// <param name="inCppForm">The form of enum.</param>
/// <param name="addMaxKeyIfMissing">Should a default Max item be added.</param>
/// <returns>true unless the MAX enum already exists and isn't the last enum.</returns>
public bool SetEnums(Dictionary <FName, long> names, UEnum.ECppForm inCppForm, bool addMaxKeyIfMissing = true)
{
using (TArrayUnsafe <FName> namesUnsafe = new TArrayUnsafe <FName>())
using (TArrayUnsafe <long> valuesUnsafe = new TArrayUnsafe <long>())
{
namesUnsafe.AddRange(names.Keys.ToArray());
valuesUnsafe.AddRange(names.Values.ToArray());
return(Native_UEnum.SetEnums(Address, namesUnsafe.Address, valuesUnsafe.Address, inCppForm, addMaxKeyIfMissing));
}
}
/// <summary>
/// Set the key/value pair in the Property's metadata
/// </summary>
/// <param name="obj">the object to set the metadata for</param>
/// <param name="value">The metadata key/value pairs</param>
public void SetObjectValues(UObject obj, Dictionary <FName, string> value)
{
using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>())
using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>())
{
keysUnsafe.AddRange(value.Keys.ToArray());
valuesUnsafe.AddRange(value.Values.ToArray());
Native_UMetaData.SetObjectValues(Address, obj == null ? IntPtr.Zero : obj.Address, keysUnsafe.Address, valuesUnsafe.Address);
}
}
public IntPtr GetAddress()
{
if (address == IntPtr.Zero)
{
return(address);
}
using (TArrayUnsafe <FName> packageNamesUnsafe = new TArrayUnsafe <FName>())
{
packageNamesUnsafe.AddRange(PackageNames.ToArray());
Native_FARFilter.Set_PackageNames(address, packageNamesUnsafe.Address);
}
using (TArrayUnsafe <FName> packagePathsUnsafe = new TArrayUnsafe <FName>())
{
packagePathsUnsafe.AddRange(PackagePaths.ToArray());
Native_FARFilter.Set_PackagePaths(address, packagePathsUnsafe.Address);
}
using (TArrayUnsafe <FName> objectPathsUnsafe = new TArrayUnsafe <FName>())
{
objectPathsUnsafe.AddRange(ObjectPaths.ToArray());
Native_FARFilter.Set_ObjectPaths(address, objectPathsUnsafe.Address);
}
using (TArrayUnsafe <FName> classNamesUnsafe = new TArrayUnsafe <FName>())
{
classNamesUnsafe.AddRange(ClassNames.ToArray());
Native_FARFilter.Set_ClassNames(address, classNamesUnsafe.Address);
}
using (TArrayUnsafe <FName> tagsUnsafe = new TArrayUnsafe <FName>())
using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>())
{
tagsUnsafe.AddRange(TagsAndValues.Keys.ToArray());
valuesUnsafe.AddRange(TagsAndValues.Values.ToArray());
Native_FARFilter.Set_TagsAndValues(address, tagsUnsafe.Address, valuesUnsafe.Address);
}
using (TArrayUnsafe <FName> recursiveClassesExclusionSet = new TArrayUnsafe <FName>())
{
recursiveClassesExclusionSet.AddRange(RecursiveClassesExclusionSet.ToArray());
Native_FARFilter.Set_RecursiveClassesExclusionSet(address, recursiveClassesExclusionSet.Address);
}
Native_FARFilter.Set_bRecursivePaths(address, RecursivePaths);
Native_FARFilter.Set_bRecursiveClasses(address, RecursiveClasses);
Native_FARFilter.Set_bIncludeOnlyOnDiskAssets(address, IncludeOnlyOnDiskAssets);
return(address);
}