自学教程：C++ GET_MEMBER_NAME_CHECKED函数代码示例

void UEnvQueryGenerator_OnCircle::PostEditChangeProperty( struct FPropertyChangedEvent& PropertyChangedEvent) {	static const FName NAME_Angle = GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, Angle);	static const FName NAME_Radius = GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, Radius);	if (PropertyChangedEvent.Property != NULL)	{		const FName PropName = PropertyChangedEvent.MemberProperty->GetFName();		if (PropName == NAME_Angle)		{			Angle.Value = FMath::Clamp(Angle.Value, 0.0f, 360.f);			AngleRadians = FMath::DegreesToRadians(Angle.Value);			bDefineArc = Angle.Value < 360.f && Angle.Value > 0.f;		}		else if (PropName == NAME_Radius)		{			if (Radius.Value <= 0.f)			{				Radius.Value = 100.f;			}		}		ItemSpacing.Value = FMath::Max(1.0f, ItemSpacing.Value);	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

void AFlySkillActor::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	FName PropertyName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None;	if ((PropertyName == GET_MEMBER_NAME_CHECKED(AFlySkillActor, UseTargetLocation)))	{		if (UseTargetLocation)		{			UseTargetActor = false;		}		else		{			UseTargetActor = true;		}	}	else if ((PropertyName == GET_MEMBER_NAME_CHECKED(AFlySkillActor, UseTargetActor)))	{		if (UseTargetActor)		{			UseTargetLocation = false;		}		else		{			UseTargetLocation = true;		}	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

void FCinematicOptionsCustomization::CustomizeChildren(TSharedRef<class IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils){	bPlayMatinee = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bPlayMatinee));	bLoop = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bLoop));	Matinee = StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, Matinee));	ChildBuilder.AddChildProperty(StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bPlayMatinee)).ToSharedRef());	ChildBuilder.AddChildProperty(StructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBTDialogueCinematicOptions, bLoop)).ToSharedRef());	ChildBuilder.AddChildContent(LOCTEXT("Matinee", "Matinee"))		.NameContent()		[			Matinee->CreatePropertyNameWidget()		]	.ValueContent()		.HAlign(HAlign_Fill)		[			SNew(SHorizontalBox)			+ SHorizontalBox::Slot()			.MaxWidth(109.0f)			[				SNew(SComboButton)				.OnGetMenuContent(this, &FCinematicOptionsCustomization::OnGetMatineeList)				.ContentPadding(FMargin(2.0f, 2.0f))				.ButtonContent()				[					SNew(STextBlock)					.Text(this, &FCinematicOptionsCustomization::GetCurrentMatineeName)					.Font(IDetailLayoutBuilder::GetDetailFont())				]			]		];}

void FFoliageTypePaintingCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailLayoutBuilder){    // Hide categories we are not going to customize    FFoliageTypeCustomizationHelpers::HideFoliageCategory(DetailLayoutBuilder, "Procedural");    FFoliageTypeCustomizationHelpers::HideFoliageCategory(DetailLayoutBuilder, "Reapply");    // Show all the properties with a reapply condition or that depend on another variable to be relevant    TMap<const FName, IDetailPropertyRow*> PropertyRowsByName;    ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "Painting", PropertyRowsByName);    ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "Placement", PropertyRowsByName);    ShowFoliagePropertiesForCategory(DetailLayoutBuilder, "InstanceSettings", PropertyRowsByName);    // Density adjustment factor should only be visible when reapplying    FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, DensityAdjustmentFactor)),            TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetReapplyModeVisibility)),            TAttribute<bool>());    // Set the scale visibility attribute for each axis    Scaling = DetailLayoutBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFoliageType, Scaling));    ReapplyScaling = DetailLayoutBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFoliageType, ReapplyScaling));    FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleX)),            TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::X)),            TAttribute<bool>());    FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleY)),            TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::Y)),            TAttribute<bool>());    FFoliageTypeCustomizationHelpers::ModifyFoliagePropertyRow(*PropertyRowsByName.Find(GET_MEMBER_NAME_CHECKED(UFoliageType, ScaleZ)),            TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FFoliageTypePaintingCustomization::GetScaleVisibility, EAxis::Z)),            TAttribute<bool>());}

void UEnvQueryGenerator_OnCircle::PostEditChangeProperty( FPropertyChangedEvent& PropertyChangedEvent) {	if (PropertyChangedEvent.Property != NULL)	{		const FName PropName = PropertyChangedEvent.MemberProperty->GetFName();		if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, ArcAngle))		{			ArcAngle.DefaultValue = FMath::Clamp(ArcAngle.DefaultValue, 0.0f, 360.f);			AngleRadians = FMath::DegreesToRadians(ArcAngle.DefaultValue);			bDefineArc = (ArcAngle.DefaultValue < 360.f) && (ArcAngle.DefaultValue > 0.f);		}		else if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, CircleRadius))		{			if (CircleRadius.DefaultValue <= 0.f)			{				CircleRadius.DefaultValue = 100.f;			}		}		else if (PropName == GET_MEMBER_NAME_CHECKED(UEnvQueryGenerator_OnCircle, SpaceBetween))		{			SpaceBetween.DefaultValue = FMath::Max(1.0f, SpaceBetween.DefaultValue);		}	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

void FTileLODEntryDetailsCustomization::CustomizeChildren(TSharedRef<IPropertyHandle> StructPropertyHandle, 																	class IDetailChildrenBuilder& ChildBuilder, 																	IPropertyTypeCustomizationUtils& StructCustomizationUtils ){	LODIndexHandle = StructPropertyHandle->GetChildHandle(		GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, LODIndex)		);		TSharedPtr<IPropertyHandle> DistanceProperty = StructPropertyHandle->GetChildHandle(		GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, Distance)		);		TSharedPtr<IPropertyHandle> SimplificationDetails = StructPropertyHandle->GetChildHandle(		GET_MEMBER_NAME_CHECKED(FTileLODEntryDetails, SimplificationDetails)		);	ChildBuilder.AddChildProperty(LODIndexHandle.ToSharedRef())		.Visibility(EVisibility::Hidden);	ChildBuilder.AddChildProperty(DistanceProperty.ToSharedRef())		.IsEnabled(TAttribute<bool>::Create(TAttribute<bool>::FGetter::CreateSP(this, &FTileLODEntryDetailsCustomization::IsLODDistanceEnabled)));		ChildBuilder.AddChildProperty(SimplificationDetails.ToSharedRef())		.IsEnabled(TAttribute<bool>::Create(TAttribute<bool>::FGetter::CreateSP(this, &FTileLODEntryDetailsCustomization::IsGenerateTileEnabled)));}

void FDerivedCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailLayout){	// So now we're customizing UDerivedClass object	// First, try to hide an inherited property	{		// 'HideMe' property is defined in UBaseClass		TSharedPtr<IPropertyHandle> PropertyToHide = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UDerivedClass, HideMe));		PropertyToHide->MarkHiddenByCustomization();	}			{		// Now grab any struct property (or property that has customized property value widget)		// Note that this is property defined in UDerivedClass!		TSharedPtr<IPropertyHandle> TestProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UDerivedClass, Vector2dProperty));		// Hide this property		TestProperty->MarkHiddenByCustomization();		// Get a category so we can add a TestProperty back to the panel		IDetailCategoryBuilder& DerivedCategory = DetailLayout.EditCategory("Derived");		DerivedCategory.AddCustomRow(LOCTEXT("DerivedObjectLabel", "Derived"))			.NameContent()			[				TestProperty->CreatePropertyNameWidget()			]		.ValueContent()			[				// This will return NullWidget - thats the problem				TestProperty->CreatePropertyValueWidget()			];	}}

void UIOSRuntimeSettings::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent){	Super::PostEditChangeProperty(PropertyChangedEvent);	// Ensure that at least one orientation is supported	if (!bSupportsPortraitOrientation && !bSupportsUpsideDownOrientation && !bSupportsLandscapeLeftOrientation && !bSupportsLandscapeRightOrientation)	{		bSupportsPortraitOrientation = true;		UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bSupportsPortraitOrientation)), GetDefaultConfigFilename());	}	// Ensure that at least one API is supported	if (!bSupportsMetal && !bSupportsOpenGLES2 && !bSupportsMetalMRT)	{		bSupportsOpenGLES2 = true;		UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bSupportsOpenGLES2)), GetDefaultConfigFilename());	}	// Ensure that at least armv7 is selected for shipping and dev	if (!bDevForArmV7 && !bDevForArm64 && !bDevForArmV7S)	{		bDevForArmV7 = true;		UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bDevForArmV7)), GetDefaultConfigFilename());	}	if (!bShipForArmV7 && !bShipForArm64 && !bShipForArmV7S)	{		bShipForArmV7 = true;		UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UIOSRuntimeSettings, bShipForArmV7)), GetDefaultConfigFilename());	}}

void FAxisMappingsNodeBuilder::OnAxisMappingNameCommitted(const FText& InName, ETextCommit::Type CommitInfo, const FMappingSet MappingSet){	const FScopedTransaction Transaction(LOCTEXT("RenameAxisMapping_Transaction", "Rename Axis Mapping"));	FName NewName = FName(*InName.ToString());	FName CurrentName = NewName;	if (MappingSet.Mappings.Num() > 0)	{		MappingSet.Mappings[0]->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->GetValue(CurrentName);	}	if (NewName != CurrentName)	{		for (int32 Index = 0; Index < MappingSet.Mappings.Num(); ++Index)		{			MappingSet.Mappings[Index]->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->SetValue(NewName);		}		if (MappingSet.DetailGroup)		{			RenamedGroupExpansionState.Key = NewName;			RenamedGroupExpansionState.Value = MappingSet.DetailGroup->GetExpansionState();			// Don't want to save expansion state of old name			MappingSet.DetailGroup->ToggleExpansion(false);		}	}}

void FCameraLensSettingsCustomization::CustomizeChildren(TSharedRef<IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils){	// Retrieve structure's child properties	uint32 NumChildren;	StructPropertyHandle->GetNumChildren(NumChildren);	TMap<FName, TSharedPtr< IPropertyHandle > > PropertyHandles;	for (uint32 ChildIndex = 0; ChildIndex < NumChildren; ++ChildIndex)	{		TSharedRef<IPropertyHandle> ChildHandle = StructPropertyHandle->GetChildHandle(ChildIndex).ToSharedRef();		const FName PropertyName = ChildHandle->GetProperty()->GetFName();		PropertyHandles.Add(PropertyName, ChildHandle);	}		// Retrieve special case properties	MinFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFocalLength));	MaxFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFocalLength));	MinFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFStop));	MaxFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFStop));	MinFocusDistanceHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinimumFocusDistance));	for (auto Iter(PropertyHandles.CreateConstIterator()); Iter; ++Iter)	{		if (Iter.Value() == MinFocusDistanceHandle)		{			// skip showing these in the panel for now, as we don't really use them			continue;		}		IDetailPropertyRow& SettingsRow = ChildBuilder.AddChildProperty(Iter.Value().ToSharedRef());	}}

void UGameMapsSettings::PostReloadConfig( UProperty* PropertyThatWasLoaded ){	if (PropertyThatWasLoaded)	{		if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, EditorStartupMap))		{			FixMapAssetRef(EditorStartupMap);		}		else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, GameDefaultMap))		{			FixMapAssetRef(GameDefaultMap);		}		else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, ServerDefaultMap))		{			FixMapAssetRef(ServerDefaultMap);		}		else if (PropertyThatWasLoaded->GetFName() == GET_MEMBER_NAME_CHECKED(UGameMapsSettings, TransitionMap))		{			FixMapAssetRef(TransitionMap);		}	}	else	{		FixMapAssetRef(EditorStartupMap);		FixMapAssetRef(GameDefaultMap);		FixMapAssetRef(ServerDefaultMap);		FixMapAssetRef(TransitionMap);	}}

void AAudioVolume::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	Super::PostEditChangeProperty(PropertyChangedEvent);	Settings.Volume = FMath::Clamp<float>( Settings.Volume, 0.0f, 1.0f );	AmbientZoneSettings.InteriorTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.InteriorTime );	AmbientZoneSettings.InteriorLPFTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.InteriorLPFTime );	AmbientZoneSettings.ExteriorTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.ExteriorTime );	AmbientZoneSettings.ExteriorLPFTime = FMath::Max<float>( 0.01f, AmbientZoneSettings.ExteriorLPFTime );	if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(AAudioVolume, Priority))	{		GetWorld()->AudioVolumes.Sort([](const AAudioVolume& A, const AAudioVolume& B) { return (A.GetPriority() > B.GetPriority()); });	}	if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(AAudioVolume, bEnabled))	{		if (bEnabled)		{			AddProxy();		}		else		{			RemoveProxy();		}	}	else if (bEnabled)	{		UpdateProxy();	}}

void ADynamicWeather::PostEditChangeProperty(FPropertyChangedEvent &Event){  Super::PostEditChangeProperty(Event);  const FName PropertyName = (Event.Property != NULL ? Event.Property->GetFName() : NAME_None);  if (PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, Weather)) {    Update();  } else if ((PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, bSaveToConfigFile)) ||             (PropertyName == GET_MEMBER_NAME_CHECKED(ADynamicWeather, bLoadFromConfigFile))) {    // Do nothing.  } else {    AdjustSunPositionBasedOnActorRotation();  }  if (bSaveToConfigFile) {    bSaveToConfigFile = false;    if (SaveToConfigFile()) {      UE_LOG(LogCarla, Log, TEXT("Weather /"%s/" saved to config file"), *Weather.Name);    } else {      UE_LOG(LogCarla, Error, TEXT("Error saving weather to config file"));    }  }  if (bLoadFromConfigFile) {    bLoadFromConfigFile = false;    if (LoadFromConfigFile()) {      UE_LOG(LogCarla, Log, TEXT("Weather /"%s/" loaded from config file"), *Weather.Name);      Update();    } else {      UE_LOG(LogCarla, Error, TEXT("Error loading weather from config file"));    }  }}

void USplineComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	if (PropertyChangedEvent.Property != nullptr)	{		const FName PropertyName(PropertyChangedEvent.Property->GetFName());		if (PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, ReparamStepsPerSegment) ||			PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, bStationaryEndpoints))		{			UpdateSpline();		}		if (PropertyName == GET_MEMBER_NAME_CHECKED(USplineComponent, bClosedLoop))		{			if (bClosedLoop)			{				// Spline is guaranteed to be non-looping when we get here (due to PreEditChange).				// Now just force the loop endpoint to be added if bClosedLoop == true.				AddLoopEndpoint();			}			UpdateSpline();		}	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

void FSpriteDetailsCustomization::BuildTextureSection(IDetailCategoryBuilder& SpriteCategory, IDetailLayoutBuilder& DetailLayout){	// Grab information about the material	TSharedPtr<IPropertyHandle> DefaultMaterialProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, DefaultMaterial));	FText SourceTextureOverrideLabel;	if (DefaultMaterialProperty.IsValid())	{		UObject* DefaultMaterialAsObject;		if (DefaultMaterialProperty->GetValue(/*out*/ DefaultMaterialAsObject) == FPropertyAccess::Success)		{			if (UMaterialInterface* DefaultMaterialInterface = Cast<UMaterialInterface>(DefaultMaterialAsObject))			{				if (UMaterial* DefaultMaterial = DefaultMaterialInterface->GetMaterial())				{					// Get a list of sprite samplers					TArray<const UMaterialExpressionSpriteTextureSampler*> SpriteSamplerExpressions;					DefaultMaterial->GetAllExpressionsOfType(/*inout*/ SpriteSamplerExpressions);					// Turn that into a set of labels					for (const UMaterialExpressionSpriteTextureSampler* Sampler : SpriteSamplerExpressions)					{						if (!Sampler->SlotDisplayName.IsEmpty())						{							if (Sampler->bSampleAdditionalTextures)							{								AdditionalTextureLabels.FindOrAdd(Sampler->AdditionalSlotIndex) = Sampler->SlotDisplayName;							}							else							{								SourceTextureOverrideLabel = Sampler->SlotDisplayName;							}						}					}				}			}		}	}	// Create the base texture widget	TSharedPtr<IPropertyHandle> SourceTextureProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, SourceTexture));	DetailLayout.HideProperty(SourceTextureProperty);	SpriteCategory.AddCustomRow(SourceTextureProperty->GetPropertyDisplayName())		.NameContent()		[			CreateTextureNameWidget(SourceTextureProperty, SourceTextureOverrideLabel)		]		.ValueContent()		.MaxDesiredWidth(TOptional<float>())		[			SourceTextureProperty->CreatePropertyValueWidget()		];	// Create the additional textures widget	TSharedPtr<IPropertyHandle> AdditionalSourceTexturesProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, AdditionalSourceTextures));	TSharedRef<FDetailArrayBuilder> AdditionalSourceTexturesBuilder = MakeShareable(new FDetailArrayBuilder(AdditionalSourceTexturesProperty.ToSharedRef()));	AdditionalSourceTexturesBuilder->OnGenerateArrayElementWidget(FOnGenerateArrayElementWidget::CreateSP(this, &FSpriteDetailsCustomization::GenerateAdditionalTextureWidget));	SpriteCategory.AddCustomBuilder(AdditionalSourceTexturesBuilder);}

void FAutoReimportManager::HandleLoadingSavingSettingChanged(FName PropertyName){	if (PropertyName == GET_MEMBER_NAME_CHECKED(UEditorLoadingSavingSettings, bMonitorContentDirectories) ||		PropertyName == GET_MEMBER_NAME_CHECKED(UEditorLoadingSavingSettings, AutoReimportDirectorySettings))	{		ResetMonitorsTimeout = FTimeLimit(5.f);	}}

UBTDecorator_UtilityBlackboard::UBTDecorator_UtilityBlackboard(const FObjectInitializer& ObjectInitializer) :Super(ObjectInitializer){	NodeName = "Blackboard Utility";	// accept only float and integer keys	UtilityValueKey.AddFloatFilter(this, GET_MEMBER_NAME_CHECKED(UBTDecorator_UtilityBlackboard, UtilityValueKey));	UtilityValueKey.AddIntFilter(this, GET_MEMBER_NAME_CHECKED(UBTDecorator_UtilityBlackboard, UtilityValueKey));}

void FBlackboardDataDetails::CustomizeDetails( IDetailLayoutBuilder& DetailLayout ){	// First hide all keys	DetailLayout.HideProperty(TEXT("Keys"));	DetailLayout.HideProperty(TEXT("ParentKeys"));	// Now show only the currently selected key	bool bIsInherited = false;	int32 CurrentSelection = INDEX_NONE;	if(OnGetSelectedBlackboardItemIndex.IsBound())	{		CurrentSelection = OnGetSelectedBlackboardItemIndex.Execute(bIsInherited);	}	if(CurrentSelection >= 0)	{		TSharedPtr<IPropertyHandle> KeysHandle = bIsInherited ? DetailLayout.GetProperty(TEXT("ParentKeys")) : DetailLayout.GetProperty(TEXT("Keys"));		check(KeysHandle.IsValid());		uint32 NumChildKeys = 0;		KeysHandle->GetNumChildren(NumChildKeys);		if((uint32)CurrentSelection < NumChildKeys)		{			TSharedPtr<IPropertyHandle> KeyHandle = KeysHandle->GetChildHandle((uint32)CurrentSelection);			IDetailCategoryBuilder& DetailCategoryBuilder = DetailLayout.EditCategory("Key");			TSharedPtr<IPropertyHandle> EntryNameProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, EntryName));			DetailCategoryBuilder.AddCustomRow(LOCTEXT("EntryNameLabel", "Entry Name"))			.NameContent()			[				EntryNameProperty->CreatePropertyNameWidget()			]			.ValueContent()			[				SNew(SHorizontalBox)				.IsEnabled(true)				+SHorizontalBox::Slot()				[					EntryNameProperty->CreatePropertyValueWidget()				]			];#if WITH_EDITORONLY_DATA// 			TSharedPtr<IPropertyHandle> EntryDescriptionHandle = ElementProperty->GetChildHandle("EntryDescription");			TSharedPtr<IPropertyHandle> EntryDescriptionHandle = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, EntryDescription));			DetailCategoryBuilder.AddProperty(EntryDescriptionHandle);#endif			TSharedPtr<IPropertyHandle> KeyTypeProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, KeyType));			DetailCategoryBuilder.AddProperty(KeyTypeProperty);			TSharedPtr<IPropertyHandle> bInstanceSyncedProperty = KeyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FBlackboardEntry, bInstanceSynced));			DetailCategoryBuilder.AddProperty(bInstanceSyncedProperty);		}		}}

// Called when property is changed in the Unreal Editorvoid AVessel::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent){	FName PropertyName = (PropertyChangedEvent.Property != NULL) ? PropertyChangedEvent.Property->GetFName() : NAME_None;		if (PropertyName == GET_MEMBER_NAME_CHECKED(AVessel, BuildStage) ||		PropertyName == GET_MEMBER_NAME_CHECKED(AVessel, FinalRotations)) {		// Set the Build Stage and Current Rotation accordingly		SetBuildStage(BuildStage);	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

UBTTask_MoveDirectlyToward::UBTTask_MoveDirectlyToward(const FObjectInitializer& ObjectInitializer) 	: Super(ObjectInitializer)	, AcceptableRadius(50.f)	, bProjectVectorGoalToNavigation(true)	, bAllowStrafe(true)	, bStopOnOverlap(false){	NodeName = "MoveDirectlyToward";	// accept only actors and vectors	BlackboardKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey), AActor::StaticClass());	BlackboardKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey));}

void FNiagaraEmitterPropertiesDetails::OnGenerateScalarConstantEntry(TSharedRef<IPropertyHandle> ElementProperty, int32 ElementIndex, IDetailChildrenBuilder& ChildrenBuilder){	TSharedPtr<IPropertyHandle> ValueProperty = ElementProperty->GetChildHandle(GET_MEMBER_NAME_CHECKED(FNiagaraConstants_Float, Value));	TSharedPtr<IPropertyHandle> NameProperty = ElementProperty->GetChildHandle(GET_MEMBER_NAME_CHECKED(FNiagaraConstants_Float, Name));	FName DisplayName;	NameProperty->GetValue(DisplayName);	//Don't display system constants	if (UNiagaraComponent::GetSystemConstants().Find(FNiagaraVariableInfo(DisplayName, ENiagaraDataType::Scalar)) == INDEX_NONE)	{		ChildrenBuilder.AddChildProperty(ValueProperty.ToSharedRef()).DisplayName(FText::FromName(DisplayName));	}}

UBTTask_FlyTo::UBTTask_FlyTo(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer){	NodeName = "Fly To";	bNotifyTick = true;		FlightLocationKey.AddVectorFilter(this,		    GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, FlightLocationKey));	FlightResultKey.AddBoolFilter(this,				GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, FlightResultKey));	KeyToFlipFlopWhenTaskExits.AddBoolFilter(this,  GET_MEMBER_NAME_CHECKED(UBTTask_FlyTo, KeyToFlipFlopWhenTaskExits));	FlightLocationKey.AllowNoneAsValue(true);	FlightResultKey.AllowNoneAsValue(true);	KeyToFlipFlopWhenTaskExits.AllowNoneAsValue(true);}

void UPaperTileMap::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	const FName PropertyName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None;	//@TODO: Determine when these are really needed, as they're seriously expensive!	FTileMapReregisterContext ReregisterTileMapComponents(this);	ValidateSelectedLayerIndex();	if (PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, HexSideLength))	{		HexSideLength = FMath::Max<int32>(HexSideLength, 0);		// The side length needs to be included in the overall tile height		TileHeight += HexSideLength;	}	TileWidth = FMath::Max(TileWidth, 1);	TileHeight = FMath::Max(TileHeight, 1);	MapWidth = FMath::Max(MapWidth, 1);	MapHeight = FMath::Max(MapHeight, 1);	if (PixelsPerUnrealUnit <= 0.0f)	{		PixelsPerUnrealUnit = 1.0f;	}	if ((PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, MapWidth)) || (PropertyName == GET_MEMBER_NAME_CHECKED(UPaperTileMap, MapHeight)))	{		ResizeMap(MapWidth, MapHeight, /*bForceResize=*/ true);	}	else	{		// Make sure that the layers are all of the right size		for (UPaperTileLayer* TileLayer : TileLayers)		{			if ((TileLayer->GetLayerWidth() != MapWidth) || (TileLayer->GetLayerHeight() != MapHeight))			{				TileLayer->Modify();				TileLayer->ResizeMap(MapWidth, MapHeight);			}		}	}	if (!IsTemplate())	{		UpdateBodySetup();	}	Super::PostEditChangeProperty(PropertyChangedEvent);}

void FInputAxisMappingCustomization::CustomizeChildren( TSharedRef<class IPropertyHandle> InStructPropertyHandle, class IDetailChildrenBuilder& StructBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils ){	TSharedPtr<IPropertyHandle> KeyHandle = InStructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, Key));	TSharedPtr<IPropertyHandle> ScaleHandle = InStructPropertyHandle->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, Scale));	TSharedRef<SWidget> RemoveButton = PropertyCustomizationHelpers::MakeDeleteButton( FSimpleDelegate::CreateSP( this, &FInputAxisMappingCustomization::RemoveAxisMappingButton_OnClick), 		LOCTEXT("RemoveAxisMappingToolTip", "Removes Axis Mapping") );	StructBuilder.AddChildContent( LOCTEXT("KeySearchStr", "Key").ToString() )	[		SNew(SHorizontalBox)		+ SHorizontalBox::Slot()		.Padding(InputConstants::PropertyPadding)		.AutoWidth()		[			SNew( SBox )			.WidthOverride( InputConstants::TextBoxWidth )			[				StructBuilder.GenerateStructValueWidget( KeyHandle.ToSharedRef() )			]		]		+SHorizontalBox::Slot()		.Padding(InputConstants::PropertyPadding)		.HAlign(HAlign_Center)		.VAlign(VAlign_Center)		.AutoWidth()		[			ScaleHandle->CreatePropertyNameWidget()		]		+SHorizontalBox::Slot()		.Padding(InputConstants::PropertyPadding)		.HAlign(HAlign_Left)		.VAlign(VAlign_Center)		.AutoWidth()		[			SNew(SBox)			.WidthOverride(InputConstants::ScaleBoxWidth)			[				ScaleHandle->CreatePropertyValueWidget()			]		]		+SHorizontalBox::Slot()		.Padding(InputConstants::PropertyPadding)		.HAlign(HAlign_Center)		.VAlign(VAlign_Center)		.AutoWidth()		[			RemoveButton		]	];}

UBTTask_MoveDirectlyToward::UBTTask_MoveDirectlyToward(const FObjectInitializer& ObjectInitializer) 	: Super(ObjectInitializer)	, bProjectVectorGoalToNavigation(true){	NodeName = "MoveDirectlyToward";	AcceptableRadius = GET_AI_CONFIG_VAR(AcceptanceRadius);	bStopOnOverlap = GET_AI_CONFIG_VAR(bFinishMoveOnGoalOverlap);	bAllowStrafe = GET_AI_CONFIG_VAR(bAllowStrafing);	// accept only actors and vectors	BlackboardKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey), AActor::StaticClass());	BlackboardKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MoveDirectlyToward, BlackboardKey));}

void UPhysicsSettings::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent){	Super::PostEditChangeProperty(PropertyChangedEvent);	const FName PropertyName = PropertyChangedEvent.Property ? PropertyChangedEvent.Property->GetFName() : NAME_None;	if (PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, FrictionCombineMode) || PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, RestitutionCombineMode))	{		UPhysicalMaterial::RebuildPhysicalMaterials();	}	else if (PropertyName == GET_MEMBER_NAME_CHECKED(UPhysicsSettings, DefaultDegreesOfFreedom))	{		UMovementComponent::PhysicsLockedAxisSettingChanged();	}}

void UGameplayCueManager::InitObjectLibraries(TArray<FString> Paths, UObjectLibrary* ActorObjectLibrary, UObjectLibrary* StaticObjectLibrary, FOnGameplayCueNotifySetLoaded OnLoadDelegate, FShouldLoadGCNotifyDelegate ShouldLoadDelegate){	DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Library"), STAT_ObjectLibrary, STATGROUP_LoadTime);#if WITH_EDITOR	bAccelerationMapOutdated = false;	FFormatNamedArguments Args;	FScopedSlowTask SlowTask(0, FText::Format(NSLOCTEXT("AbilitySystemEditor", "BeginLoadingGameplayCueNotify", "Loading GameplayCue Library"), Args));	SlowTask.MakeDialog();#endif	FScopeCycleCounterUObject PreloadScopeActor(ActorObjectLibrary);	ActorObjectLibrary->LoadBlueprintAssetDataFromPaths(Paths);	StaticObjectLibrary->LoadBlueprintAssetDataFromPaths(Paths);	// ---------------------------------------------------------	// Determine loading scheme.	// Sync at startup in commandlets like cook.	// Async at startup in all other cases	// ---------------------------------------------------------	const bool bSyncFullyLoad = IsRunningCommandlet();	const bool bAsyncLoadAtStartup = !bSyncFullyLoad && ShouldAsyncLoadAtStartup();	if (bSyncFullyLoad)	{#if STATS		FString PerfMessage = FString::Printf(TEXT("Fully Loaded GameplayCueNotify object library"));		SCOPE_LOG_TIME_IN_SECONDS(*PerfMessage, nullptr)#endif		ActorObjectLibrary->LoadAssetsFromAssetData();		StaticObjectLibrary->LoadAssetsFromAssetData();	}	// ---------------------------------------------------------	// Look for GameplayCueNotifies that handle events	// ---------------------------------------------------------		TArray<FAssetData> ActorAssetDatas;	ActorObjectLibrary->GetAssetDataList(ActorAssetDatas);	TArray<FAssetData> StaticAssetDatas;	StaticObjectLibrary->GetAssetDataList(StaticAssetDatas);	TArray<FGameplayCueReferencePair> CuesToAdd;	BuildCuesToAddToGlobalSet(ActorAssetDatas, GET_MEMBER_NAME_CHECKED(AGameplayCueNotify_Actor, GameplayCueName), bAsyncLoadAtStartup, CuesToAdd, OnLoadDelegate, ShouldLoadDelegate);	BuildCuesToAddToGlobalSet(StaticAssetDatas, GET_MEMBER_NAME_CHECKED(UGameplayCueNotify_Static, GameplayCueName), bAsyncLoadAtStartup, CuesToAdd, OnLoadDelegate, ShouldLoadDelegate);	check(GlobalCueSet);	GlobalCueSet->AddCues(CuesToAdd);}

void FAxisMappingsNodeBuilder::RebuildGroupedMappings(){	GroupedMappings.Empty();	TSharedPtr<IPropertyHandleArray> AxisMappingsArrayHandle = AxisMappingsPropertyHandle->AsArray();	uint32 NumMappings;	AxisMappingsArrayHandle->GetNumElements(NumMappings);	for (uint32 Index = 0; Index < NumMappings; ++Index)	{		TSharedRef<IPropertyHandle> AxisMapping = AxisMappingsArrayHandle->GetElement(Index);		FName AxisName;		FPropertyAccess::Result Result = AxisMapping->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->GetValue(AxisName);		if (Result == FPropertyAccess::Success)		{			int32 FoundIndex = INDEX_NONE;			for (int32 GroupIndex = 0; GroupIndex < GroupedMappings.Num(); ++GroupIndex)			{				if (GroupedMappings[GroupIndex].SharedName == AxisName)				{					FoundIndex = GroupIndex;					break;				}			}			if (FoundIndex == INDEX_NONE)			{				FoundIndex = GroupedMappings.Num();				GroupedMappings.AddZeroed();				GroupedMappings[FoundIndex].SharedName = AxisName;			}			GroupedMappings[FoundIndex].Mappings.Add(AxisMapping);		}	}}

void USoundMix::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	if (PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive && PropertyChangedEvent.MemberProperty)	{		if (PropertyChangedEvent.MemberProperty->GetFName() == GET_MEMBER_NAME_CHECKED(USoundMix,SoundClassEffects))		{			TArray<USoundClass*> ProblemClasses;			if (CausesPassiveDependencyLoop(ProblemClasses))			{				for (int32 Index = 0; Index < ProblemClasses.Num(); Index++)				{					FFormatNamedArguments Arguments;					Arguments.Add(TEXT("SoundClass"), FText::FromString(ProblemClasses[Index]->GetName()));					Arguments.Add(TEXT("SoundMix"), FText::FromString(GetName()));					FNotificationInfo Info(FText::Format(NSLOCTEXT("Engine", "PassiveSoundMixLoop", "Passive dependency created by Sound Class'{SoundClass}' and Sound Mix'{SoundMix}' - results may be undesirable"), Arguments));					Info.ExpireDuration = 10.0f;					Info.Image = FCoreStyle::Get().GetBrush(TEXT("MessageLog.Warning"));					FSlateNotificationManager::Get().AddNotification(Info);				}			}		}	}#if WITH_EDITORONLY_DATA	bChanged = true;#endif}

void USoundWave::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){	Super::PostEditChangeProperty(PropertyChangedEvent);	static FName CompressionQualityFName = FName( TEXT( "CompressionQuality" ) );	static FName StreamingFName = GET_MEMBER_NAME_CHECKED(USoundWave, bStreaming);	// Prevent constant re-compression of SoundWave while properties are being changed interactively	if (PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive)	{		UProperty* PropertyThatChanged = PropertyChangedEvent.Property;		// Regenerate on save any compressed sound formats		if ( PropertyThatChanged && PropertyThatChanged->GetFName() == CompressionQualityFName )		{			InvalidateCompressedData();			FreeResources();			UpdatePlatformData();			MarkPackageDirty();		}		else if (PropertyThatChanged && PropertyThatChanged->GetFName() == StreamingFName)		{			FreeResources();			UpdatePlatformData();			MarkPackageDirty();		}	}}