vault backup: 2024-10-12 17:19:45

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/Bitflags/Bitflags.md

@@ -0,0 +1,50 @@
+# Bitflags
+
+- **功能描述：** 设定一个枚举支持采用位标记赋值，从而在蓝图中可以识别出来是BitMask
+- **使用位置：** UENUM
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **关联项：** [UseEnumValuesAsMaskValuesInEditor](../UseEnumValuesAsMaskValuesInEditor/UseEnumValuesAsMaskValuesInEditor.md)
+- **常用程度：** ★★★★★
+
+常常和UPROPERTY上的bitmask一起配合使用。
+
+注意这个和UENUM(flags)的区别，后者是影响C++里字符串输出函数。
+
+这个是指定该枚举支持位标记，从而在蓝图中可以被选择出来。
+
+```cpp
+UENUM(BlueprintType,Flags)
+enum class EMyEnum_Flags:uint8
+{
+	First,
+	Second,
+	Third,
+};
+UENUM(BlueprintType,Meta = (Bitflags))
+enum class EMyEnum_BitFlags:uint8
+{
+	First,
+	Second,
+	Third,
+};
+
+//源码中的例子：
+UENUM(Meta = (Bitflags))
+enum class EColorBits
+{
+ECB_Red,
+ECB_Green,
+ECB_Blue
+};
+UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EColorBits"))
+int32 ColorFlags;
+```
+
+如下图所示：EMyEnum_Flags就不会被列在选项里。而EMyEnum_BitFlags就可以被列进来。
+
+![Untitled](Untitled.png)
+
+如果没有UPROPERTY(bitmask)的配合使用，则蓝图里还是只能单项选择
+
+![Untitled1](Untitled1.png)

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/Bitmask/Bitmask.md

@@ -0,0 +1,58 @@
+# Bitmask
+
+- **功能描述：** 设定一个属性采用Bitmask赋值
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **限制类型：** 用来表示枚举值的int32
+- **关联项：** [BitmaskEnum](../BitmaskEnum/BitmaskEnum.md)
+- **常用程度：** ★★★★★
+
+这个标记和enum身上的定义并没有一定的关系，因此可以单独定义。
+
+```cpp
+UENUM(BlueprintType)
+enum class EMyEnum_Normal:uint8
+{
+	First,
+	Second,
+	Third,
+};
+
+UENUM(BlueprintType,Flags)
+enum class EMyEnum_Flags:uint8
+{
+	First,
+	Second,
+	Third,
+};
+
+UENUM(BlueprintType,Meta = (Bitflags))
+enum class EMyEnum_BitFlags:uint8
+{
+	First,
+	Second,
+	Third,
+};
+
+UCLASS(Blueprintable, BlueprintType)
+class INSIDER_API AMyActor_EnumBitFlags_Test:public AActor
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EMyEnum_Normal"))
+	int32 MyNormal;
+
+	UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EMyEnum_Flags"))
+	int32 MyFlags;
+
+	UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EMyEnum_BitFlags"))
+	int32 MyBitFlags;
+};
+```
+
+都是可以在蓝图中用标记来定义
+
+![Untitled](Untitled.png)
+
+可以用BitmaskEnum进一步提供枚举值

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/BitmaskEnum/BitmaskEnum.md

@@ -0,0 +1,25 @@
+# BitmaskEnum
+
+- **功能描述：** 使用位标记后采用的枚举名字
+- **使用位置：** UPROPERTY
+- **元数据类型：** string="abc"
+- **限制类型：** 用来表示枚举值的int32
+- **关联项：** [Bitmask](../Bitmask/Bitmask.md)
+- **常用程度：** ★★★★★
+
+如果没有标上BitmaskEnum，则无法提供标记的的名称值
+
+```cpp
+UCLASS(Blueprintable, BlueprintType)
+class INSIDER_API AMyActor_EnumBitFlags_Test:public AActor
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditAnywhere, Meta = (Bitmask))
+	int32 MyNormalWithoutEnum;
+};
+```
+
+如果没有标上BitmaskEnum，则无法提供标记的的名称值
+
+![Untitled](Untitled.png)

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/Enum.md

@@ -0,0 +1,9 @@
+# Enum
+
+- **功能描述：** 给一个String指定以枚举里值的名称作为选项
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** string="abc"
+- **限制类型：** FString
+- **关联项：** [ValidEnumValues](ValidEnumValues/ValidEnumValues.md)
+- **常用程度：** ★★★

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/EnumDisplayNameFn/EnumDisplayNameFn.md

@@ -0,0 +1,124 @@
+# EnumDisplayNameFn
+
+- **功能描述：** 在Runtime下为枚举字段提供自定义名称的函数回调
+- **使用位置：** UENUM
+- **引擎模块：** Enum Property
+- **元数据类型：** string="abc"
+- **常用程度：** ★★
+
+只在Runtime下生效，在Editor下依然不起作用。
+
+## 测试代码：
+
+```cpp
+//[EMyEnum_CustomDisplay	Enum->Field->Object	/Script/Insider.EMyEnum_CustomDisplay]
+//(BlueprintType = true, EnumDisplayNameFn = GetMyEnumCustomDisplayName, First.Name = EMyEnum_CustomDisplay::First, IsBlueprintBase = true, ModuleRelativePath = Enum/MyEnum_Test.h, Second.Name = EMyEnum_CustomDisplay::Second, Third.Name = EMyEnum_CustomDisplay::Third)
+//	ObjectFlags:	RF_Public | RF_Transient 
+//	Outer:	Package /Script/Insider
+//	EnumFlags:	EEnumFlags::None
+//	EnumDisplayNameFn:	6adb4804
+//	CppType:	EMyEnum_CustomDisplay
+//	CppForm:	EnumClass
+//{
+//	First = 0,
+//	Second = 1,
+//	Third = 2,
+//	EMyEnum_MAX = 3
+//};
+
+UENUM(Blueprintable, meta = (EnumDisplayNameFn = "GetMyEnumCustomDisplayName"))
+enum class EMyEnum_CustomDisplay :uint8
+{
+	First,
+	Second,
+	Third,
+};
+
+extern FText GetMyEnumCustomDisplayName(int32 val);
+
+FText GetMyEnumCustomDisplayName(int32 val)
+{
+	EMyEnum_CustomDisplay enumValue = (EMyEnum_CustomDisplay)val;
+	switch (enumValue)
+	{
+	case EMyEnum_CustomDisplay::First:
+		return FText::FromString(TEXT("My_First"));
+	case EMyEnum_CustomDisplay::Second:
+		return FText::FromString(TEXT("My_Second"));
+	case EMyEnum_CustomDisplay::Third:
+		return FText::FromString(TEXT("My_Third"));
+	default:
+		return FText::FromString(TEXT("Invalid MyEnum"));
+	}
+}
+```
+
+## 测试蓝图：
+
+![Untitled](Untitled.png)
+
+EnumDisplayNameFn 的函数设置是在gen.cpp中完成的，因此并不需要成为UFUNCTION。
+
+```cpp
+const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Insider_EMyEnum_CustomDisplay_Statics::EnumParams = {
+	(UObject*(*)())Z_Construct_UPackage__Script_Insider,
+	GetMyEnumCustomDisplayName,             //这里！！！
+	"EMyEnum_CustomDisplay",
+	"EMyEnum_CustomDisplay",
+	Z_Construct_UEnum_Insider_EMyEnum_CustomDisplay_Statics::Enumerators,
+	RF_Public|RF_Transient|RF_MarkAsNative,
+	UE_ARRAY_COUNT(Z_Construct_UEnum_Insider_EMyEnum_CustomDisplay_Statics::Enumerators),
+	EEnumFlags::None,
+	(uint8)UEnum::ECppForm::EnumClass,
+	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Insider_EMyEnum_CustomDisplay_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Insider_EMyEnum_CustomDisplay_Statics::Enum_MetaDataParams)
+};
+```
+
+## 原理代码：
+
+```cpp
+
+/FText UEnum::GetDisplayNameTextByIndex(int32 NameIndex) const
+{
+	FString RawName = GetNameStringByIndex(NameIndex);
+
+	if (RawName.IsEmpty())
+	{
+		return FText::GetEmpty();
+	}
+
+#if WITH_EDITOR
+	FText LocalizedDisplayName;
+	// In the editor, use metadata and localization to look up names
+	static const FString Namespace = TEXT("UObjectDisplayNames");
+	const FString Key = GetFullGroupName(false) + TEXT(".") + RawName;
+
+	FString NativeDisplayName;
+	if (HasMetaData(TEXT("DisplayName"), NameIndex))
+	{
+		NativeDisplayName = GetMetaData(TEXT("DisplayName"), NameIndex);
+	}
+	else
+	{
+		NativeDisplayName = FName::NameToDisplayString(RawName, false);
+	}
+
+	if (!(FText::FindText(Namespace, Key, /*OUT*/LocalizedDisplayName, &NativeDisplayName)))
+	{
+		LocalizedDisplayName = FText::FromString(NativeDisplayName);
+	}
+
+	if (!LocalizedDisplayName.IsEmpty())
+	{
+		return LocalizedDisplayName;
+	}
+#endif
+	//Runtime下到这里
+	if (EnumDisplayNameFn)
+	{
+		return (*EnumDisplayNameFn)(NameIndex);
+	}
+
+	return FText::FromString(GetNameStringByIndex(NameIndex));
+}
+```

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/EnumValueDisplayNameOverrides/EnumValueDisplayNameOverrides.md

@@ -0,0 +1,35 @@
+# EnumValueDisplayNameOverrides
+
+- **功能描述：** 改变枚举属性值上的显示名字
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** string="abc"
+- **关联项：** [ValidEnumValues](../ValidEnumValues/ValidEnumValues.md)
+- **常用程度：** ★★
+
+给枚举属性上的枚举值进行一些改名，可以改变多个，按照“A=B;C=D”的格式列出即可。收集到的信息是TMap<FName, FText>映射，因此要同时提供原枚举值名称和新的显示名称配对。
+
+## 测试代码：
+
+```cpp
+UENUM(BlueprintType)
+enum class EMyPropertyTestEnum : uint8
+{
+	First,
+	Second,
+	Third,
+	Forth,
+	Fifth,
+};
+
+UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (EnumValueDisplayNameOverrides = "First=Cat;Second=Dog"))
+EMyPropertyTestEnum MyEnumWithDisplayNameOverrides;
+```
+
+## 蓝图效果：
+
+可见实际上改变了First、Second的显示名字。
+
+![Untitled](Untitled.png)
+
+原理代码见ValidEnumValues上的代码

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/GetRestrictedEnumValues.md

@@ -0,0 +1,17 @@
+# GetRestrictedEnumValues
+
+- **功能描述：** 指定一个函数来指定枚举属性值的哪些枚举选项是禁用的
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** string="abc"
+- **限制类型：** TArray<FString> FuncName() const;
+- **关联项：** [ValidEnumValues](ValidEnumValues/ValidEnumValues.md)
+- **常用程度：** ★★★
+
+Restricted和Invalid的区别是：
+
+Invalid会隐藏掉该选项值
+
+Restricted依然会显示该选项值，只是会灰调不可选。
+
+指定的函数名字必须是一个UFUNCTION函数，这样才能通过名字找到该函数。

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/InvalidEnumValues.md

@@ -0,0 +1,11 @@
+# InvalidEnumValues
+
+- **功能描述：** 指定枚举属性值上不可选的枚举值选项，用以排除一些选项
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** strings="a，b，c"
+- **限制类型：** 枚举属性值
+- **关联项：** [ValidEnumValues](ValidEnumValues/ValidEnumValues.md)
+- **常用程度：** ★★★
+
+如果同时指定了InvalidEnumValues和ValidEnumValues，且里面的值有重叠，则还是以InvalidEnumValues的为准：这项枚举值就是非法的。

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/DisplayName/DisplayName.md

@@ -0,0 +1,52 @@
+# DisplayName
+
+- **功能描述：** 改变枚举值的显示名称
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **元数据类型：** string="abc"
+- **常用程度：** ★★★★★
+
+改变枚举值的显示名称
+
+## 示例代码：
+
+```cpp
+/*
+[enum 602d0d4e680 EMyEnum_HasDisplayName	Enum->Field->Object	/Script/Insider.EMyEnum_HasDisplayName]
+(BlueprintType = true, First.DisplayName = Dog, First.Name = EMyEnum_HasDisplayName::First, IsBlueprintBase = true, ModuleRelativePath = Enum/MyEnum_Test.h, Second.DisplayName = Cat, Second.Name = EMyEnum_HasDisplayName::Second, Third.DisplayName = Pig, Third.Name = EMyEnum_HasDisplayName::Third)
+	ObjectFlags:	RF_Public | RF_Transient 
+	Outer:	Package /Script/Insider
+	EnumFlags:	None
+	EnumDisplayNameFn:	0
+	CppType:	EMyEnum_HasDisplayName
+	CppForm:	EnumClass
+{
+	First = 0,
+	Second = 1,
+	Third = 2,
+	EMyEnum_MAX = 3
+};
+*/
+UENUM(Blueprintable)
+enum class EMyEnum_HasDisplayName :uint8
+{
+	First UMETA(DisplayName="Dog"),
+	Second UMETA(DisplayName="Cat"),
+	Third UMETA(DisplayName="Pig"),
+};
+
+UCLASS(BlueprintType)
+class INSIDER_API UMyEnum_Test :public UObject
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditAnywhere,BlueprintReadWrite)
+	EMyEnum_HasDisplayName MyEnum_HasDisplayName;
+}
+```
+
+## 示例效果：
+
+可见改变了名称。
+
+![image](image.png)

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/DisplayValue.md

@@ -0,0 +1,19 @@
+# DisplayValue
+
+- **功能描述：** Enum /Script/Engine.AnimPhysCollisionType
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **常用程度：** 0
+
+## 源码例子：
+
+```cpp
+UENUM()
+enum class AnimPhysCollisionType : uint8
+{
+	CoM UMETA(DisplayName="CoM", DisplayValue="CoM", ToolTip="Only limit the center of mass from crossing planes."),
+	CustomSphere UMETA(ToolTip="Use the specified sphere radius to collide with planes."),
+	InnerSphere UMETA(ToolTip="Use the largest sphere that fits entirely within the body extents to collide with planes."),
+	OuterSphere UMETA(ToolTip="Use the smallest sphere that wholely contains the body extents to collide with planes.")
+};
+```

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/Grouping.md

@@ -0,0 +1,82 @@
+# Grouping
+
+- **功能描述：** Enum /Script/Engine.EAlphaBlendOption
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **常用程度：** 0
+
+感觉是用在Sequencer里面的，只用在SEasingFunctionGridWidget里面。
+
+## 源码例子：
+
+```cpp
+UENUM()
+enum class EAlphaBlendOption : uint8
+{
+	Linear = 0 UMETA(Grouping = Linear, DisplayName = "Linear", ToolTip = "Linear interpolation"),
+	Cubic UMETA(Grouping = Cubic, DisplayName = "Cubic In", ToolTip = "Cubic-in interpolation"),
+	HermiteCubic UMETA(Grouping = Cubic, DisplayName = "Hermite-Cubic InOut", ToolTip = "Hermite-Cubic"),
+	Sinusoidal UMETA(Grouping = Sinusoidal, DisplayName = "Sinusoidal", ToolTip = "Sinusoidal interpolation"),
+	QuadraticInOut UMETA(Grouping = Quadratic, DisplayName = "Quadratic InOut", ToolTip = "Quadratic in-out interpolation"),
+	CubicInOut UMETA(Grouping = Cubic, DisplayName = "Cubic InOut", ToolTip = "Cubic in-out interpolation"),
+	QuarticInOut UMETA(Grouping = Quartic, DisplayName = "Quartic InOut", ToolTip = "Quartic in-out interpolation"),
+	QuinticInOut UMETA(Grouping = Quintic, DisplayName = "Quintic InOut", ToolTip = "Quintic in-out interpolation"),
+	CircularIn UMETA(Grouping = Circular, DisplayName = "Circular In", ToolTip = "Circular-in interpolation"),
+	CircularOut UMETA(Grouping = Circular, DisplayName = "Circular Out", ToolTip = "Circular-out interpolation"),
+	CircularInOut UMETA(Grouping = Circular, DisplayName = "Circular InOut", ToolTip = "Circular in-out interpolation"),
+	ExpIn UMETA(Grouping = Exponential, DisplayName = "Exponential In", ToolTip = "Exponential-in interpolation"),
+	ExpOut UMETA(Grouping = Exponential, DisplayName = "Exponential Out", ToolTip = "Exponential-Out interpolation"),
+	ExpInOut UMETA(Grouping = Exponential, DisplayName = "Exponential InOut", ToolTip = "Exponential in-out interpolation"),
+	Custom UMETA(Grouping = Custom, DisplayName = "Custom", ToolTip = "Custom interpolation, will use custom curve inside an FAlphaBlend or linear if none has been set"),
+};
+
+UENUM()
+enum class EMovieSceneBuiltInEasing : uint8
+{
+	// Linear easing
+	Linear UMETA(Grouping=Linear,DisplayName="Linear"),
+	// Sinusoidal easing
+	SinIn UMETA(Grouping=Sinusoidal,DisplayName="Sinusoidal In"), SinOut UMETA(Grouping=Sinusoidal,DisplayName="Sinusoidal Out"), SinInOut UMETA(Grouping=Sinusoidal,DisplayName="Sinusoidal InOut"),
+	// Quadratic easing
+	QuadIn UMETA(Grouping=Quadratic,DisplayName="Quadratic In"), QuadOut UMETA(Grouping=Quadratic,DisplayName="Quadratic Out"), QuadInOut UMETA(Grouping=Quadratic,DisplayName="Quadratic InOut"),
+	// Cubic easing
+	Cubic UMETA(Grouping = Cubic, DisplayName = "Cubic"), CubicIn UMETA(Grouping=Cubic,DisplayName="Cubic In"), CubicOut UMETA(Grouping=Cubic,DisplayName="Cubic Out"), CubicInOut UMETA(Grouping=Cubic,DisplayName="Cubic InOut"), HermiteCubicInOut UMETA(Grouping = Cubic, DisplayName = "Hermite-Cubic InOut"),
+	// Quartic easing
+	QuartIn UMETA(Grouping=Quartic,DisplayName="Quartic In"), QuartOut UMETA(Grouping=Quartic,DisplayName="Quartic Out"), QuartInOut UMETA(Grouping=Quartic,DisplayName="Quartic InOut"),
+	// Quintic easing
+	QuintIn UMETA(Grouping=Quintic,DisplayName="Quintic In"), QuintOut UMETA(Grouping=Quintic,DisplayName="Quintic Out"), QuintInOut UMETA(Grouping=Quintic,DisplayName="Quintic InOut"),
+	// Exponential easing
+	ExpoIn UMETA(Grouping=Exponential,DisplayName="Exponential In"), ExpoOut UMETA(Grouping=Exponential,DisplayName="Exponential Out"), ExpoInOut UMETA(Grouping=Exponential,DisplayName="Exponential InOut"),
+	// Circular easing
+	CircIn UMETA(Grouping=Circular,DisplayName="Circular In"), CircOut UMETA(Grouping=Circular,DisplayName="Circular Out"), CircInOut UMETA(Grouping=Circular,DisplayName="Circular InOut"),
+	// Custom
+	Custom UMETA(Grouping = Custom, DisplayName = "Custom"),
+};
+
+```
+
+## 原理：
+
+```cpp
+TArray<SEasingFunctionGridWidget::FGroup> SEasingFunctionGridWidget::ConstructGroups(const TSet<EMovieSceneBuiltInEasing>& FilterExclude)
+{
+	const UEnum* EasingEnum = StaticEnum<EMovieSceneBuiltInEasing>();
+	check(EasingEnum)
+
+	TArray<FGroup> Groups;
+
+	for (int32 NameIndex = 0; NameIndex < EasingEnum->NumEnums() - 1; ++NameIndex)
+	{
+		const FString& Grouping = EasingEnum->GetMetaData(TEXT("Grouping"), NameIndex);
+		EMovieSceneBuiltInEasing Value = (EMovieSceneBuiltInEasing)EasingEnum->GetValueByIndex(NameIndex);
+
+		if (FilterExclude.IsEmpty() || FilterExclude.Find(Value) == nullptr)
+		{
+			FindOrAddGroup(Groups, Grouping).Values.Add(Value);
+		}
+	}
+
+	return Groups;
+}
+```

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/Hidden/Hidden.md

@@ -0,0 +1,84 @@
+# Hidden
+
+- **功能描述：** 隐藏UENUM的某个值
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **限制类型：** UENUM的值
+- **常用程度：** ★★★★★
+
+隐藏UENUM的某个值。
+
+## 测试代码：
+
+```cpp
+
+UENUM(Blueprintable,BlueprintType)
+enum class EMyEnum_Spacer_Hidden :uint8
+{
+	MyNormal,
+	MySpacer UMETA(Spacer),
+	MyHidden UMETA(Hidden),
+};
+
+UCLASS(BlueprintType)
+class INSIDER_API UMyEnum_Test :public UObject
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditAnywhere,BlueprintReadWrite)
+	EMyEnum_Spacer_Hidden MyEnum_Spacer_Hidden;
+};
+```
+
+## 测试效果：
+
+![Untitled](5b4de771-be09-4342-8955-dc0f824ef97d.png)
+
+但是蓝图里访问：
+
+![Untitled](Untitled.png)
+
+## 原理：
+
+在属性细节面板里生成枚举可能的值的时候，会判断Hidden和Spacer选项来隐藏。
+
+但是在SEnumComboBox和SGraphPinEnum这种在蓝图里显示的时候，只会判断Hidden，而没有（忘了？）判断Spacer，因此MySpacer是依然会被显示出来。
+
+```cpp
+bool FPropertyHandleBase::GeneratePossibleValues(TArray<FString>& OutOptionStrings, TArray< FText >& OutToolTips, TArray<bool>& OutRestrictedItems, TArray<FText>* OutDisplayNames)
+{
+		// Ignore hidden enums
+	bool bShouldBeHidden = Enum->HasMetaData(TEXT("Hidden"), EnumIndex ) || Enum->HasMetaData(TEXT("Spacer"), EnumIndex );
+	if (!bShouldBeHidden)
+	{
+		if(ValidEnumValues.Num() > 0)
+		{
+			bShouldBeHidden = !ValidEnumValues.Contains(Enum->GetNameByIndex(EnumIndex));
+		}
+		// If both are specified, InvalidEnumValues takes precedence
+		else if(InvalidEnumValues.Num() > 0)
+		{
+			bShouldBeHidden = InvalidEnumValues.Contains(Enum->GetNameByIndex(EnumIndex));
+		}
+	}
+}
+
+void SEnumComboBox::Construct(const FArguments& InArgs, const UEnum* InEnum)
+{
+		if (Enum->HasMetaData(TEXT("Hidden"), Index) == false)
+		{
+			VisibleEnums.Emplace(Index, Enum->GetValueByIndex(Index), Enum->GetDisplayNameTextByIndex(Index), Enum->GetToolTipTextByIndex(Index));
+		}
+}
+
+void SGraphPinEnum::GenerateComboBoxIndexes( TArray< TSharedPtr<int32> >& OutComboBoxIndexes )
+{
+	// Ignore hidden enum values
+	if( !EnumPtr->HasMetaData(TEXT("Hidden"), EnumIndex ) )
+	{
+		TSharedPtr<int32> EnumIdxPtr(new int32(EnumIndex));
+		OutComboBoxIndexes.Add(EnumIdxPtr);
+	}
+}
+```

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/Spacer.md

@@ -0,0 +1,16 @@
+# Spacer
+
+- **功能描述：** 隐藏UENUM的某个值
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **限制类型：** UENUM
+- **常用程度：** ★★★★★
+
+Spacer和Hidden的功能大体是一致的。唯一区别是Spacer在蓝图里==的时候还是会显示出来。
+
+因此还是建议如果要隐藏枚举值，还是要尽量都用Hidden。
+
+![Untitled](Hidden/Untitled.png)
+
+其他示例代码见Hidden

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UMETA/TraceQuery.md

@@ -0,0 +1,72 @@
+# TraceQuery
+
+- **功能描述：** Enum /Script/Engine.ECollisionChannel
+- **使用位置：** UENUM::UMETA
+- **引擎模块：** Enum Property
+- **元数据类型：** bool
+- **常用程度：** 0
+
+只在ECollisionChannel 上使用，指定哪些通道是用来Trace的。
+
+## 源码例子：
+
+```cpp
+UENUM(BlueprintType)
+enum ECollisionChannel : int
+{
+
+	ECC_WorldStatic UMETA(DisplayName="WorldStatic"),
+	ECC_WorldDynamic UMETA(DisplayName="WorldDynamic"),
+	ECC_Pawn UMETA(DisplayName="Pawn"),
+	ECC_Visibility UMETA(DisplayName="Visibility" , TraceQuery="1"),
+	ECC_Camera UMETA(DisplayName="Camera" , TraceQuery="1"),
+	ECC_PhysicsBody UMETA(DisplayName="PhysicsBody"),
+	ECC_Vehicle UMETA(DisplayName="Vehicle"),
+	ECC_Destructible UMETA(DisplayName="Destructible"),
+
+	/** Reserved for gizmo collision */
+	ECC_EngineTraceChannel1 UMETA(Hidden),
+
+	ECC_EngineTraceChannel2 UMETA(Hidden),
+	ECC_EngineTraceChannel3 UMETA(Hidden),
+	ECC_EngineTraceChannel4 UMETA(Hidden), 
+	ECC_EngineTraceChannel5 UMETA(Hidden),
+	ECC_EngineTraceChannel6 UMETA(Hidden),
+
+	ECC_GameTraceChannel1 UMETA(Hidden),
+	ECC_GameTraceChannel2 UMETA(Hidden),
+	ECC_GameTraceChannel3 UMETA(Hidden),
+	ECC_GameTraceChannel4 UMETA(Hidden),
+	ECC_GameTraceChannel5 UMETA(Hidden),
+	ECC_GameTraceChannel6 UMETA(Hidden),
+	ECC_GameTraceChannel7 UMETA(Hidden),
+	ECC_GameTraceChannel8 UMETA(Hidden),
+	ECC_GameTraceChannel9 UMETA(Hidden),
+	ECC_GameTraceChannel10 UMETA(Hidden),
+	ECC_GameTraceChannel11 UMETA(Hidden),
+	ECC_GameTraceChannel12 UMETA(Hidden),
+	ECC_GameTraceChannel13 UMETA(Hidden),
+	ECC_GameTraceChannel14 UMETA(Hidden),
+	ECC_GameTraceChannel15 UMETA(Hidden),
+	ECC_GameTraceChannel16 UMETA(Hidden),
+	ECC_GameTraceChannel17 UMETA(Hidden),
+	ECC_GameTraceChannel18 UMETA(Hidden),
+	
+	/** Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) */
+	/** Add only nonserialized/transient flags below */
+
+	// NOTE!!!! THESE ARE BEING DEPRECATED BUT STILL THERE FOR BLUEPRINT. PLEASE DO NOT USE THEM IN CODE
+
+	ECC_OverlapAll_Deprecated UMETA(Hidden),
+	ECC_MAX,
+};
+```
+
+## 原理：
+
+```cpp
+void UCollisionProfile::LoadProfileConfig(bool bForceInit)
+{
+		static const FString TraceType = TEXT("TraceQuery");
+}
+```

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/UseEnumValuesAsMaskValuesInEditor/UseEnumValuesAsMaskValuesInEditor.md

@@ -0,0 +1,64 @@
+# UseEnumValuesAsMaskValuesInEditor
+
+- **功能描述：** 指定枚举值已经是位移后的值，而不是位标记的索引下标。
+- **使用位置：** UENUM
+- **元数据类型：** bool
+- **关联项：** [Bitflags](../Bitflags/Bitflags.md)
+- **常用程度：** ★★
+
+指定在编辑器里的枚举值直接就是位标记的最终值，而不是标记位。但是注意在C++里的定义是一样的形式：
+
+```cpp
+UENUM(BlueprintType, meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
+enum class EMotionExtractor_MotionType : uint8
+{
+	None				= 0 UMETA(Hidden),
+	Translation			= 1 << 0,
+	Rotation			= 1 << 1,
+	Scale				= 1 << 2,
+	TranslationSpeed	= 1 << 3,
+	RotationSpeed		= 1 << 4,
+};
+
+UENUM(meta = (Bitflags))
+enum class EPCGChangeType : uint8
+{
+	None = 0,
+	Cosmetic = 1 << 0,
+	Settings = 1 << 1,
+	Input = 1 << 2,
+	Edge = 1 << 3,
+	Node = 1 << 4,
+	Structural = 1 << 5
+};
+```
+
+## 测试的代码：
+
+```cpp
+UENUM(BlueprintType,Meta = (Bitflags))
+enum class EMyEnum_BitFlags:uint8
+{
+	First,//0
+	Second,//1
+	Third,//2
+};
+
+UENUM(BlueprintType, meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
+enum class EMyEnum_BitFlagsInEditor:uint8
+{
+	First,//0
+	Second,//1
+	Third,//2
+};
+```
+
+## 测试的蓝图1：
+
+![Untitled_a](Untitled_a.png)
+
+## 测试的蓝图2：
+
+![Untitled_b](Untitled_b.png)
+
+因此可以看出前者是1<<2+1<<2，而后者是1|2，因此后者是直接把枚举值作为已经位移后的值

03-UnrealEngine/Gameplay/UObject/UnrealSpecifiers/Meta/Enum/ValidEnumValues/ValidEnumValues.md

@@ -0,0 +1,150 @@
+# ValidEnumValues
+
+- **功能描述：** 指定枚举属性值上可选的枚举值选项
+- **使用位置：** UPROPERTY
+- **引擎模块：** Enum Property
+- **元数据类型：** strings="a，b，c"
+- **限制类型：** 枚举属性值
+- **关联项：** [InvalidEnumValues](../InvalidEnumValues.md), [GetRestrictedEnumValues](../GetRestrictedEnumValues.md), [EnumValueDisplayNameOverrides](../EnumValueDisplayNameOverrides/EnumValueDisplayNameOverrides.md), [Enum](../Enum.md)
+- **常用程度：** ★★★
+
+指定枚举属性值上可选的枚举值选项，默认情况下。枚举属性在细节面板上可选项为全部的枚举值，但我们可以通过ValidEnumValues来限制只展示这些值。
+
+枚举属性的写法有3种，分别是enum class，TEnumAsByte和FString叠加enum meta的写法，这3种写法都会被视为一个枚举属性然后尝试产生combo list来让用户选择属性值。
+
+## 示例代码：
+
+```cpp
+UENUM(BlueprintType)
+enum class EMyPropertyTestEnum : uint8
+{
+	First,
+	Second,
+	Third,
+	Forth,
+	Fifth,
+};
+
+UENUM(BlueprintType)
+namespace EMyPropertyTestEnum2
+{
+	enum Type : int
+	{
+		First,
+		Second,
+		Third,
+		Forth,
+		Fifth,
+	};
+}
+
+UCLASS(BlueprintType)
+class INSIDER_API UMyProperty_Enum :public UObject
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	EMyPropertyTestEnum MyEnum;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ValidEnumValues = "First,Second,Third"))
+	EMyPropertyTestEnum MyEnumWithValid;	// Type 1
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ValidEnumValues = "First,Second,Third"))
+	TEnumAsByte<EMyPropertyTestEnum2::Type> MyAnotherEnumWithValid;	//Type 2
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (enum = "EMyPropertyTestEnum"))
+	FString MyStringWithEnum;	//Type 3
+	
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (InvalidEnumValues = "First,Second,Third"))
+	EMyPropertyTestEnum MyEnumWithInvalid = EMyPropertyTestEnum::Forth;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (GetRestrictedEnumValues = "MyGetRestrictedEnumValues"))
+	EMyPropertyTestEnum MyEnumWithRestricted;
+
+public:
+	UFUNCTION(BlueprintInternalUseOnly)
+	TArray<FString> MyGetRestrictedEnumValues() const{	return TArray<FString>{"Second","Third"};}
+};
+```
+
+## 蓝图效果：
+
+可见默认情况下枚举属性会显示全部5个枚举值，但其他3个枚举属性值的可选列表被限制到了3个。
+
+![Untitled](Untitled.png)
+
+## 原理：
+
+下述的代码，
+
+```cpp
+bool FPropertyHandleBase::GeneratePossibleValues(TArray< TSharedPtr<FString> >& OutOptionStrings, TArray< FText >& OutToolTips, TArray<bool>& OutRestrictedItems)
+{
+	TArray<UObject*> OuterObjects;
+	GetOuterObjects(OuterObjects);		
+	
+	const TArray<FName> ValidEnumValues = PropertyEditorHelpers::GetValidEnumsFromPropertyOverride(Property, Enum);
+	const TArray<FName> InvalidEnumValues = PropertyEditorHelpers::GetInvalidEnumsFromPropertyOverride(Property, Enum);
+	const TArray<FName> RestrictedEnumValues = PropertyEditorHelpers::GetRestrictedEnumsFromPropertyOverride(OuterObjects, Property, Enum);
+	
+	const TMap<FName, FText> EnumValueDisplayNameOverrides = PropertyEditorHelpers::GetEnumValueDisplayNamesFromPropertyOverride(Property, Enum);
+	
+	//NumEnums() - 1, because the last item in an enum is the _MAX item
+	for( int32 EnumIndex = 0; EnumIndex < Enum->NumEnums() - 1; ++EnumIndex )
+	{
+		// Ignore hidden enums
+		bool bShouldBeHidden = Enum->HasMetaData(TEXT("Hidden"), EnumIndex ) || Enum->HasMetaData(TEXT("Spacer"), EnumIndex );
+		if (!bShouldBeHidden)
+		{
+			if(ValidEnumValues.Num() > 0)
+			{
+				bShouldBeHidden = !ValidEnumValues.Contains(Enum->GetNameByIndex(EnumIndex));
+			}
+			// If both are specified, InvalidEnumValues takes precedence
+			else if(InvalidEnumValues.Num() > 0)
+			{
+				bShouldBeHidden = InvalidEnumValues.Contains(Enum->GetNameByIndex(EnumIndex));
+			}
+		}
+	
+		if (!bShouldBeHidden)
+		{
+			bShouldBeHidden = IsHidden(Enum->GetNameStringByIndex(EnumIndex));
+		}
+	
+		if( !bShouldBeHidden )
+		{
+			// See if we specified an alternate name for this value using metadata
+			FString EnumName = Enum->GetNameStringByIndex(EnumIndex);
+			FString EnumDisplayName = EnumValueDisplayNameOverrides.FindRef(Enum->GetNameByIndex(EnumIndex)).ToString();
+			if (EnumDisplayName.IsEmpty())
+			{
+				EnumDisplayName = Enum->GetDisplayNameTextByIndex(EnumIndex).ToString();
+			}
+	
+			FText RestrictionTooltip;
+			const bool bIsRestricted = GenerateRestrictionToolTip(EnumName, RestrictionTooltip) || RestrictedEnumValues.Contains(Enum->GetNameByIndex(EnumIndex));
+			OutRestrictedItems.Add(bIsRestricted);
+	
+			if (EnumDisplayName.Len() == 0)
+			{
+				EnumDisplayName = MoveTemp(EnumName);
+			}
+			else
+			{
+				bUsesAlternateDisplayValues = true;
+			}
+	
+			TSharedPtr< FString > EnumStr(new FString(EnumDisplayName));
+			OutOptionStrings.Add(EnumStr);
+	
+			FText EnumValueToolTip = bIsRestricted ? RestrictionTooltip : Enum->GetToolTipTextByIndex(EnumIndex);
+			OutToolTips.Add(MoveTemp(EnumValueToolTip));
+		}
+		else
+		{
+			OutToolTips.Add(FText());
+		}
+	}
+}
+```