public override void SetMetaData(Dictionary <FName, string> metadata) { if (Flags.HasFlag(PropFlags.Instanced)) { metadata[UMeta.GetKeyName(MDProp.EditInline)] = "true"; } }
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); } }
private static void SetOrClearMetaDataClassCollection(MDClass key, Dictionary <FName, string> values, HashSet <string> collection) { if (collection.Count > 0) { values[UMeta.GetKeyName(key)] = string.Join(" ", collection); } else { values.Remove(UMeta.GetKeyName(key)); } }
public static void SetMetaData <TEnum, T>(this UField field, TEnum key, T value) where TEnum : struct { string valueStr = null; UClass unrealClass = value as UClass; if (unrealClass != null) { valueStr = unrealClass.GetPathName(); } else { valueStr = value.ToString(); } field.SetMetaData(UMeta.GetKey(key), valueStr); }
public override void SetMetaData(Dictionary <FName, string> metadata) { // HeaderParser.cpp just adds an empty string for tagged functions so this should be fine metadata[UMeta.GetKeyName(MDFunc.BlueprintSetter)] = FunctionName; }
public UMetaAttribute(MDFunc key, int value) : this(UMeta.GetKey(key), value.ToString()) { }
public static bool GetBoolMetaData <TEnum>(this UField field, TEnum key) where TEnum : struct { return(field.GetBoolMetaData(UMeta.GetKey(key))); }
private void AppendAttribute(CSharpTextBuilder builder, UField field, UnrealModuleInfo module, bool isCollapsedMember) { UnrealModuleType moduleType; UnrealModuleType moduleAssetType; string moduleName = GetModuleName(field, out moduleType, out moduleAssetType); if (string.IsNullOrEmpty(moduleName)) { moduleName = module.Name; } List <string> attributes = new List <string>(); // TODO: Combine all of this into EPropertyType (add some TypeCode into UField?) bool isInterface = false; UEnum unrealEnum = field as UEnum; UClass unrealClass = field as UClass; UScriptStruct unrealStruct = field as UScriptStruct; UFunction unrealFunction = field as UFunction; if (unrealFunction != null) { if (unrealFunction.HasAnyFunctionFlags(EFunctionFlags.Delegate)) { attributes.Add("UDelegate"); } else { if (isCollapsedMember) { // The Flags here might not contain too useful information if there is both a get/set function. // Maybe include a second flags var? attributes.Add("UFunctionAsProp(Flags=0x" + ((uint)unrealFunction.FunctionFlags).ToString("X8") + ")"); } else { attributes.Add("UFunction(Flags=0x" + ((uint)unrealFunction.FunctionFlags).ToString("X8") + ")"); } } } UProperty unrealProperty = field as UProperty; if (unrealProperty != null) { attributes.Add("UProperty(Flags=(PropFlags)0x" + ((ulong)unrealProperty.PropertyFlags).ToString("X16") + ")"); } if (unrealStruct != null) { attributes.Add("UStruct(Flags=0x" + ((uint)unrealStruct.StructFlags).ToString("X8") + ")"); } else if (unrealClass != null) { // Abstract isn't really required but might help with code browsing to know what is abstract // and what isn't. Therefore put it at the start of the attributes list. if (unrealClass.HasAnyClassFlags(EClassFlags.Abstract)) { attributes.Add("Abstract"); } isInterface = unrealClass.IsChildOf <UInterface>(); if (isInterface) { attributes.Add("UInterface(Flags=0x" + ((uint)unrealClass.ClassFlags).ToString("X8") + ")"); } else { // Should we skip "inherit" config name? string configNameStr = string.Empty; if (unrealClass.ClassConfigName != FName.None && !unrealClass.ClassConfigName.ToString().Equals("inherit", StringComparison.InvariantCultureIgnoreCase)) { configNameStr = ", Config=\"" + unrealClass.ClassConfigName + "\""; } attributes.Add("UClass(Flags=(ClassFlags)0x" + ((uint)unrealClass.ClassFlags).ToString("X8") + configNameStr + ")"); } } if (unrealEnum != null) { attributes.Add("UEnum"); } if (unrealEnum != null || unrealClass != null || unrealStruct != null) { bool blueprintType = false; bool blueprintable = false; if (unrealEnum != null) { blueprintType = field.GetBoolMetaData(MDClass.BlueprintType); } else { GetBlueprintability(field as UStruct, out blueprintType, out blueprintable); } if (blueprintType) { attributes.Add(UMeta.GetKey(MDClass.BlueprintType)); } if (unrealClass != null && blueprintable) { attributes.Add(UMeta.GetKey(MDClass.Blueprintable)); } if (isInterface) { } attributes.Add("UMetaPath(\"" + field.GetPathName() + "\", \"" + moduleName + "\", UnrealModuleType." + GetUnrealModuleTypeString(moduleType, moduleAssetType) + (isInterface ? ", InterfaceImpl=typeof(" + GetTypeName(unrealClass, null) + "Impl" + ")" : string.Empty) + ")"); } else { attributes.Add("UMetaPath(\"" + field.GetPathName() + "\")"); } if (attributes.Count > 0) { builder.AppendLine("[" + string.Join(", ", attributes) + "]"); } }
public UMetaAttribute(MDInterface key, int value) : this(UMeta.GetKey(key), value.ToString()) { }
////////////////////////////////////////////////////// // MDInterface ////////////////////////////////////////////////////// public UMetaAttribute(MDInterface key, string value) : this(UMeta.GetKey(key), value) { }
public UMetaAttribute(MDEnum key, bool value) : this(UMeta.GetKey(key), value.ToString()) { }
public static bool GeStringMetaDataHierarchical <TEnum>(this UStruct unrealStruct, TEnum key) where TEnum : struct { return(unrealStruct.GeStringMetaDataHierarchical(new FName(UMeta.GetKey(key)))); }
public static UClass GetClassMetaData <TEnum>(this UField field, TEnum key) where TEnum : struct { return(field.GetClassMetaData(UMeta.GetKey(key))); }
public static float GetFloatMetaData <TEnum>(this UField field, TEnum key) where TEnum : struct { return(field.GetFloatMetaData(UMeta.GetKey(key))); }
public override void SetMetaData(Dictionary <FName, string> metadata) { metadata[UMeta.GetKeyName(MDProp.ExposeOnSpawn)] = "true"; }
private static void MetaDataMergeClassCategories(IntPtr metadata, IntPtr obj, Dictionary <FName, string> values) { // Copying the logic in FClassDeclarationMetaData::MergeClassCategories // Engine\Source\Programs\UnrealHeaderTool\Private\ClassDeclarationMetaData.cpp // ShowFunctions HideFunctions // HideCategories ShowCategories ShowSubCatgories // AutoExpandCategories AutoCollapseCategories // - How is ShowFunctions / HideFunctions used? Hiding a function doesn't seem to hide it from being // visible in the actions list in Blueprint. If it isn't super important we could skip it. // - ShowCategories / HideCategories is important // Maybe cache these lists and clear them for each type HashSet <string> showCategories = new HashSet <string>(); HashSet <string> hideCategories = new HashSet <string>(); HashSet <string> showSubCategories = new HashSet <string>(); HashSet <string> showFunctions = new HashSet <string>(); HashSet <string> hideFunctions = new HashSet <string>(); HashSet <string> autoExpandCategories = new HashSet <string>(); HashSet <string> autoCollapseCategories = new HashSet <string>(); HashSet <string> dontAutoCollapseCategories = new HashSet <string>(); HashSet <string> classGroupNames = new HashSet <string>(); GetMetaDataItems(UMeta.GetKeyName(MDClass.ShowCategories), values, showCategories); GetMetaDataItems(UMeta.GetKeyName(MDClass.HideCategories), values, hideCategories); GetMetaDataItems(UMeta.GetKeyName(MDClass.ShowFunctions), values, showFunctions); GetMetaDataItems(UMeta.GetKeyName(MDClass.HideFunctions), values, hideFunctions); GetMetaDataItems(UMeta.GetKeyName(MDClass.AutoExpandCategories), values, autoExpandCategories); GetMetaDataItems(UMeta.GetKeyName(MDClass.AutoCollapseCategories), values, autoCollapseCategories); GetMetaDataItems(UMeta.GetKeyName(MDClass.DontAutoCollapseCategories), values, dontAutoCollapseCategories); GetMetaDataItems(UMeta.GetKeyName(MDClass.ClassGroupNames), values, classGroupNames); IntPtr parentClass = Native_UClass.GetSuperClass(obj); HashSet <string> parentHideCategories = new HashSet <string>(); HashSet <string> parentShowSubCatgories = new HashSet <string>(); HashSet <string> parentHideFunctions = new HashSet <string>(); HashSet <string> parentAutoExpandCategories = new HashSet <string>(); HashSet <string> parentAutoCollapseCategories = new HashSet <string>(); GetParentMetaDataItems(metadata, parentClass, UMeta.GetKeyName(MDClass.HideCategories), parentHideCategories); GetParentMetaDataItems(metadata, parentClass, UMeta.GetKeyName(MDClass.ShowCategories), parentShowSubCatgories); GetParentMetaDataItems(metadata, parentClass, UMeta.GetKeyName(MDClass.HideFunctions), parentHideFunctions); GetParentMetaDataItems(metadata, parentClass, UMeta.GetKeyName(MDClass.AutoExpandCategories), parentAutoExpandCategories); GetParentMetaDataItems(metadata, parentClass, UMeta.GetKeyName(MDClass.AutoCollapseCategories), parentAutoCollapseCategories); // Add parent categories. We store the opposite of HideCategories and HideFunctions in a separate array anyway. MetaDataMergeCollection(hideCategories, parentHideCategories); MetaDataMergeCollection(showSubCategories, parentShowSubCatgories); MetaDataMergeCollection(hideFunctions, parentHideFunctions); MetaDataMergeShowCategories(showCategories, hideCategories, showSubCategories); // Merge ShowFunctions and HideFunctions foreach (string value in showFunctions) { hideFunctions.Remove(value); } //showFunctions.Clear(); // Merge DontAutoCollapseCategories and AutoCollapseCategories foreach (string value in dontAutoCollapseCategories) { autoCollapseCategories.Remove(value); } //dontAutoCollapseCategories.Clear(); // The original function then merges ShowFunctions / HideFunctions again? (ShowFunctions will now be empty) // Merge AutoExpandCategories and AutoCollapseCategories (we still want to keep AutoExpandCategories though!) foreach (string value in autoExpandCategories) { autoCollapseCategories.Remove(value); parentAutoCollapseCategories.Remove(value); } // Do the same as above but the other way around foreach (string value in autoCollapseCategories) { autoExpandCategories.Remove(value); parentAutoExpandCategories.Remove(value); } // Once AutoExpandCategories and AutoCollapseCategories for THIS class have been parsed, add the parent inherited categories MetaDataMergeCollection(autoCollapseCategories, parentAutoCollapseCategories); MetaDataMergeCollection(autoExpandCategories, parentAutoExpandCategories); SetOrClearMetaDataClassCollection(MDClass.ClassGroupNames, values, classGroupNames); SetOrClearMetaDataClassCollection(MDClass.AutoCollapseCategories, values, autoCollapseCategories); SetOrClearMetaDataClassCollection(MDClass.HideCategories, values, hideCategories); SetOrClearMetaDataClassCollection(MDClass.ShowCategories, values, showSubCategories); SetOrClearMetaDataClassCollection(MDClass.HideFunctions, values, hideFunctions); SetOrClearMetaDataClassCollection(MDClass.AutoExpandCategories, values, autoExpandCategories); }
public UMetaAttribute(MD key, float value) : this(UMeta.GetKey(key), value.ToString()) { }
private static void SetMetaDataBlueprintability(Dictionary <FName, string> values, UMeta.Target target, ManagedUnrealTypeInfo typeInfo) { ManagedUnrealVisibility.Type defaultTypeVisibility = ManagedUnrealVisibility.Type.None; switch (target) { case UMeta.Target.Class: defaultTypeVisibility = ManagedUnrealVisibility.Class; break; case UMeta.Target.Interface: defaultTypeVisibility = ManagedUnrealVisibility.Interface; break; case UMeta.Target.Struct: defaultTypeVisibility = ManagedUnrealVisibility.Struct; break; case UMeta.Target.Enum: defaultTypeVisibility = ManagedUnrealVisibility.Enum; break; default: return; } if (defaultTypeVisibility == ManagedUnrealVisibility.Type.None) { return; } // Use whatever state is in typeInfo if default state is enabled. It should have been resolved // properly for our managed type (if the state was defined on a native type the default state config // should have overridden it) if (defaultTypeVisibility.HasFlag(ManagedUnrealVisibility.Type.BlueprintType)) { if (typeInfo.AdditionalFlags.HasFlag(ManagedUnrealTypeInfoFlags.BlueprintTypeHierarchical)) { values[UMeta.GetKeyName(MDClass.BlueprintType)] = "true"; values.Remove(UMeta.GetKeyName(MDClass.NotBlueprintType)); } else { values[UMeta.GetKeyName(MDClass.NotBlueprintType)] = "true"; values.Remove(UMeta.GetKeyName(MDClass.BlueprintType)); } } if (defaultTypeVisibility.HasFlag(ManagedUnrealVisibility.Type.Blueprintable)) { if (typeInfo.AdditionalFlags.HasFlag(ManagedUnrealTypeInfoFlags.BlueprintableHierarchical)) { values[UMeta.GetKeyName(MDClass.Blueprintable)] = "true"; values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "true"; values.Remove(UMeta.GetKeyName(MDClass.NotBlueprintable)); } else { values[UMeta.GetKeyName(MDClass.NotBlueprintType)] = "true"; values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "false"; values.Remove(UMeta.GetKeyName(MDClass.Blueprintable)); } } }
public UMetaAttribute(MD key, UClass value) : this(UMeta.GetKey(key), value == null ? string.Empty : value.GetPathName()) { }
private void AppendAttribute(CSharpTextBuilder builder, UField field, UnrealModuleInfo module, bool isCollapsedMember) { UnrealModuleType moduleType; UnrealModuleType moduleAssetType; string moduleName = GetModuleName(field, out moduleType, out moduleAssetType); if (string.IsNullOrEmpty(moduleName)) { moduleName = module.Name; } List <string> attributes = new List <string>(); // TODO: Combine all of this into EPropertyType (add some TypeCode into UField?) bool isInterface = false; UEnum unrealEnum = field as UEnum; UClass unrealClass = field as UClass; UScriptStruct unrealStruct = field as UScriptStruct; UFunction unrealFunction = field as UFunction; if (unrealFunction != null) { if (unrealFunction.HasAnyFunctionFlags(EFunctionFlags.Delegate)) { attributes.Add("UDelegate"); } else { string additionalFunctionInfo = string.Empty; // TODO: Only get the script name for virtual functions / interface functions as we currently only need // this for finding the base function for hooking things up to the native base types. string scriptFunctionName; if (unrealFunction.GetScriptName(out scriptFunctionName)) { additionalFunctionInfo += ", OriginalName=\"" + unrealFunction.GetName() + "\""; } if (isCollapsedMember) { // The Flags here might not contain too useful information if there is both a get/set function. // Maybe include a second flags var? attributes.Add("UFunctionAsProp(Flags=0x" + ((uint)unrealFunction.FunctionFlags).ToString("X8") + additionalFunctionInfo + ")"); } else { attributes.Add("UFunction(Flags=0x" + ((uint)unrealFunction.FunctionFlags).ToString("X8") + additionalFunctionInfo + ")"); } } } UProperty unrealProperty = field as UProperty; if (unrealProperty != null) { attributes.Add("UProperty(Flags=(PropFlags)0x" + ((ulong)unrealProperty.PropertyFlags).ToString("X16") + ")"); } if (unrealStruct != null) { attributes.Add("UStruct(Flags=0x" + ((uint)unrealStruct.StructFlags).ToString("X8") + ")"); } else if (unrealClass != null) { // Abstract isn't really required but might help with code browsing to know what is abstract // and what isn't. Therefore put it at the start of the attributes list. if (unrealClass.HasAnyClassFlags(EClassFlags.Abstract)) { attributes.Add("Abstract"); } isInterface = unrealClass.IsChildOf <UInterface>(); if (isInterface) { attributes.Add("UInterface(Flags=0x" + ((uint)unrealClass.ClassFlags).ToString("X8") + ")"); } else { attributes.Add("UClass(Flags=(ClassFlags)0x" + ((uint)unrealClass.ClassFlags).ToString("X8") + ")"); } } if (unrealEnum != null) { attributes.Add("UEnum"); } if (unrealEnum != null || unrealClass != null || unrealStruct != null) { bool blueprintType = false; bool blueprintable = false; if (unrealEnum != null) { blueprintType = field.GetBoolMetaData(MDClass.BlueprintType); } else { GetBlueprintability(field as UStruct, out blueprintType, out blueprintable); } if (blueprintType) { attributes.Add(UMeta.GetKey(MDClass.BlueprintType)); } if (unrealClass != null && blueprintable) { attributes.Add(UMeta.GetKey(MDClass.Blueprintable)); } attributes.Add("UMetaPath(\"" + field.GetPathName() + "\"" + (isInterface ? ", InterfaceImpl=typeof(" + GetTypeName(unrealClass, null) + "Impl" + ")" : string.Empty) + ")"); } else { attributes.Add("UMetaPath(\"" + field.GetPathName() + "\")"); } if (attributes.Count > 0) { builder.AppendLine("[" + string.Join(", ", attributes) + "]"); } }
////////////////////////////////////////////////////// // MDFunc ////////////////////////////////////////////////////// public UMetaAttribute(MDFunc key, string value) : this(UMeta.GetKey(key), value) { }