Files
UnrealEngine/Engine/Source/Editor/DetailCustomizations/Private/SceneCaptureDetails.cpp
2025-05-18 13:04:45 +08:00

527 lines
20 KiB
C++

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SceneCaptureDetails.h"
#include "Components/SceneCaptureComponent.h"
#include "Components/SceneCaptureComponent2D.h"
#include "Components/SceneCaptureComponentCube.h"
#include "Containers/Array.h"
#include "CoreTypes.h"
#include "DetailCategoryBuilder.h"
#include "DetailLayoutBuilder.h"
#include "DetailWidgetRow.h"
#include "Fonts/SlateFontInfo.h"
#include "GameFramework/Actor.h"
#include "HAL/PlatformCrt.h"
#include "IDetailGroup.h"
#include "IRenderCaptureProvider.h"
#include "Input/Reply.h"
#include "Internationalization/Internationalization.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Attribute.h"
#include "PropertyHandle.h"
#include "RenderCaptureInterface.h"
#include "ScopedTransaction.h"
#include "ShowFlags.h"
#include "SlotBase.h"
#include "Styling/SlateTypes.h"
#include "Templates/Casts.h"
#include "Types/SlateEnums.h"
#include "UObject/Class.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/UnrealType.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SCheckBox.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Text/STextBlock.h"
#define LOCTEXT_NAMESPACE "SceneCaptureDetails"
TSharedRef<IDetailCustomization> FSceneCaptureDetails::MakeInstance()
{
return MakeShareable( new FSceneCaptureDetails );
}
namespace UE
{
namespace DetailsCustomization
{
namespace Private
{
// Used to sort the show flags inside of their categories in the order of the text that is actually displayed
inline static bool SortAlphabeticallyByLocalizedText(const FString& ip1, const FString& ip2)
{
FText LocalizedText1;
FEngineShowFlags::FindShowFlagDisplayName(ip1, LocalizedText1);
FText LocalizedText2;
FEngineShowFlags::FindShowFlagDisplayName(ip2, LocalizedText2);
return LocalizedText1.ToString() < LocalizedText2.ToString();
}
// Utility function to get a show flag state by name.
static bool GetShowFlagState(const USceneCaptureComponent* SceneCaptureComponent, FStringView ShowFlagName)
{
if (!IsValid(SceneCaptureComponent))
{
return false;
}
const int32 SettingIndex = SceneCaptureComponent->ShowFlags.FindIndexByName(ShowFlagName.GetData());
return SettingIndex != INDEX_NONE ? SceneCaptureComponent->ShowFlags.GetSingleFlag(SettingIndex) : false;
}
// Update archetype instances so that once the value matches the default, the instance override will be removed. This correctly mimics the behavior of other checkbox states.
static void UpdateArchetypeChainShowFlagSettings(USceneCaptureComponent* SceneCaptureComponent, FStringView ShowFlagName, bool bEnabledState)
{
if (!IsValid(SceneCaptureComponent))
{
return;
}
FProperty* ShowFlagsSettingsPropertyVariable = FindFieldChecked<FProperty>(USceneCaptureComponent::StaticClass(), GET_MEMBER_NAME_CHECKED(USceneCaptureComponent, ShowFlagSettings));
FPropertyChangedEvent PropertyChangedEvent(ShowFlagsSettingsPropertyVariable);
// Update archetype instances so that once the value matches the default, the instance override will be removed.
// This correctly mimics the behavior of other checkbox states.
TArray<UObject*> Instances;
SceneCaptureComponent->GetArchetypeInstances(Instances);
for (UObject* Instance : Instances)
{
if (USceneCaptureComponent* InstanceComponent = Cast<USceneCaptureComponent>(Instance))
{
TArray<FEngineShowFlagsSetting> InstanceShowFlagSettings = InstanceComponent->GetShowFlagSettings();
const int32 RemovedElements = InstanceShowFlagSettings.RemoveAll([ShowFlagName, bEnabledState](const FEngineShowFlagsSetting& InSetting)
{
return ShowFlagName.Equals(InSetting.ShowFlagName) && (bEnabledState == InSetting.Enabled);
});
if (RemovedElements > 0)
{
InstanceComponent->PreEditChange(ShowFlagsSettingsPropertyVariable);
InstanceComponent->SetShowFlagSettings(InstanceShowFlagSettings);
InstanceComponent->PostEditChangeProperty(PropertyChangedEvent);
}
}
}
}
}
}
}
void FSceneCaptureDetails::CustomizeDetails( IDetailLayoutBuilder& DetailLayout )
{
IDetailCategoryBuilder& SceneCaptureCategoryBuilder = DetailLayout.EditCategory("SceneCapture");
ShowFlagSettingsProperty = DetailLayout.GetProperty("ShowFlagSettings", USceneCaptureComponent::StaticClass());
check(ShowFlagSettingsProperty->IsValidHandle());
ShowFlagSettingsProperty->MarkHiddenByCustomization();
// Add all the properties that are there by default
// (These would get added by default anyway, but we want to add them first so what we add next comes later in the list)
TArray<TSharedRef<IPropertyHandle>> SceneCaptureCategoryDefaultProperties;
SceneCaptureCategoryBuilder.GetDefaultProperties(SceneCaptureCategoryDefaultProperties);
for (TSharedRef<IPropertyHandle> Handle : SceneCaptureCategoryDefaultProperties)
{
if (Handle->GetProperty() != ShowFlagSettingsProperty->GetProperty())
{
SceneCaptureCategoryBuilder.AddProperty(Handle);
}
}
// Show flags that should be exposed for Scene Captures
TArray<FEngineShowFlags::EShowFlag> ShowFlagsToAllowForCaptures;
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Atmosphere);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Cloud);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_BSP);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Decals);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Fog);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Landscape);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Particles);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_SkeletalMeshes);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_StaticMeshes);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Translucency);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Lighting);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_DeferredLighting);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_NaniteMeshes);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_InstancedStaticMeshes);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_InstancedFoliage);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_InstancedGrass);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Paper2DSprites);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_TextRender);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_AmbientOcclusion);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_DynamicShadows);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_SkyLighting);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_VolumetricFog);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_AmbientCubemap);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_DistanceFieldAO);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_LightFunctions);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_LightShafts);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_PostProcessing);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_ReflectionEnvironment);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_ScreenSpaceReflections);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_TexturedLightProfiles);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_AntiAliasing);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_TemporalAA);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_MotionBlur);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Bloom);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_LocalExposure);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_EyeAdaptation);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Game);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_ToneCurve);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_PathTracing);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_Tonemapper);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_PostProcessMaterial);
ShowFlagsToAllowForCaptures.Add(FEngineShowFlags::EShowFlag::SF_AllowPrimitiveAlphaHoldout);
// Create array of flag name strings for each group
TArray< TArray<FString> > ShowFlagsByGroup;
for (int32 GroupIndex = 0; GroupIndex < SFG_Max; ++GroupIndex)
{
ShowFlagsByGroup.Add(TArray<FString>());
}
// Add the show flags we want to expose to their group's array
for (FEngineShowFlags::EShowFlag AllowedFlag : ShowFlagsToAllowForCaptures)
{
FString FlagName;
FlagName = FEngineShowFlags::FindNameByIndex(AllowedFlag);
if (!FlagName.IsEmpty())
{
EShowFlagGroup Group = FEngineShowFlags::FindShowFlagGroup(*FlagName);
ShowFlagsByGroup[Group].Add(FlagName);
}
}
// Sort the flags in their respective group alphabetically
for (TArray<FString>& ShowFlagGroup : ShowFlagsByGroup)
{
ShowFlagGroup.Sort(UE::DetailsCustomization::Private::SortAlphabeticallyByLocalizedText);
}
// Add each group
for (int32 GroupIndex = 0; GroupIndex < SFG_Max; ++GroupIndex)
{
// Don't add a group if there are no flags allowed for it
if (ShowFlagsByGroup[GroupIndex].Num() >= 1)
{
FText GroupName;
FText GroupTooltip;
switch (GroupIndex)
{
case SFG_Normal:
GroupName = LOCTEXT("CommonShowFlagHeader", "General Show Flags");
break;
case SFG_Advanced:
GroupName = LOCTEXT("AdvancedShowFlagsMenu", "Advanced Show Flags");
break;
case SFG_PostProcess:
GroupName = LOCTEXT("PostProcessShowFlagsMenu", "Post Processing Show Flags");
break;
case SFG_Developer:
GroupName = LOCTEXT("DeveloperShowFlagsMenu", "Developer Show Flags");
break;
case SFG_Visualize:
GroupName = LOCTEXT("VisualizeShowFlagsMenu", "Visualize Show Flags");
break;
case SFG_LightTypes:
GroupName = LOCTEXT("LightTypesShowFlagsMenu", "Light Types Show Flags");
break;
case SFG_LightingComponents:
GroupName = LOCTEXT("LightingComponentsShowFlagsMenu", "Lighting Components Show Flags");
break;
case SFG_LightingFeatures:
GroupName = LOCTEXT("LightingFeaturesShowFlagsMenu", "Lighting Features Show Flags");
break;
case SFG_Lumen:
GroupName = LOCTEXT("LumenFeaturesShowFlagsMenu", "Lumen Show Flags");
break;
case SFG_Nanite:
GroupName = LOCTEXT("NaniteFeaturesShowFlagsMenu", "Nanite Show Flags");
break;
case SFG_CollisionModes:
GroupName = LOCTEXT("CollisionModesShowFlagsMenu", "Collision Modes Show Flags");
break;
case SFG_Hidden:
case SFG_Transient:
GroupName = LOCTEXT("HiddenShowFlagsMenu", "Hidden Show Flags");
break;
default:
// Should not get here unless a new group is added without being updated here
GroupName = LOCTEXT("MiscFlagsMenu", "Misc Show Flags");
break;
}
FName GroupFName = FName(*(GroupName.ToString()));
IDetailGroup& Group = SceneCaptureCategoryBuilder.AddGroup(GroupFName, GroupName, true);
// Add each show flag for this group
for (FString& FlagName : ShowFlagsByGroup[GroupIndex])
{
bool bFlagHidden = false;
FText LocalizedText;
FEngineShowFlags::FindShowFlagDisplayName(FlagName, LocalizedText);
Group.AddWidgetRow()
.IsEnabled(true)
.OverrideResetToDefault(FResetToDefaultOverride::Create(TAttribute<bool>::CreateSP(this, &FSceneCaptureDetails::GetShowFlagResetVisibility, FlagName), FSimpleDelegate::CreateSP(this, &FSceneCaptureDetails::OnResetShowFlag, FlagName)))
.NameContent()
[
SNew(STextBlock)
.Text(LocalizedText)
]
.ValueContent()
[
SNew(SCheckBox)
.OnCheckStateChanged(this, &FSceneCaptureDetails::OnShowFlagCheckStateChanged, FlagName)
.IsChecked(this, &FSceneCaptureDetails::OnGetDisplayCheckState, FlagName)
]
.FilterString(LocalizedText);
}
}
}
if (IRenderCaptureProvider::IsAvailable())
{
IDetailCategoryBuilder& DebugCategoryBuilder = DetailLayout.EditCategory("Debug");
TArray<TWeakObjectPtr<UObject>> Objects;
DetailLayout.GetObjectsBeingCustomized(Objects);
const FText RenderCaptureText = LOCTEXT("RenderCaptureText", "Render Capture");
const FText RenderCaptureTooltip = LOCTEXT("RenderCaptureTooltip", "Triggers a render capture and opens it in the enabled render capture software (e.g. Render Doc, if RenderDocPlugin is enabled)");
DebugCategoryBuilder.AddCustomRow(RenderCaptureText).WholeRowContent()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
.AutoWidth()
.Padding(5.0f, 0.0f, 0.0f, 0.0f)
[
SNew(SButton)
.ToolTipText(RenderCaptureTooltip)
.IsEnabled_Lambda([Objects]() -> bool
{
for (TWeakObjectPtr<UObject> Object : Objects)
{
if (Object.IsValid() &&
(Object->IsA<USceneCaptureComponent2D>() || Object->IsA<USceneCaptureComponentCube>()))
{
return true;
}
}
return false;
})
.OnClicked_Lambda([Objects]() -> FReply
{
for (TWeakObjectPtr<UObject> Object : Objects)
{
if (USceneCaptureComponent* SceneCaptureComponent = Cast<USceneCaptureComponent>(Object.Get()))
{
RenderCaptureInterface::FScopedCapture RenderCapture(/*bEnable = */true, *FString::Format(TEXT("Scene Capture : {0}"), { SceneCaptureComponent->GetOwner()->GetActorLabel() }));
if (USceneCaptureComponent2D* SceneCaptureComponent2D = Cast<USceneCaptureComponent2D>(SceneCaptureComponent))
{
SceneCaptureComponent2D->CaptureScene();
}
else if (USceneCaptureComponentCube* SceneCaptureComponentCube = Cast<USceneCaptureComponentCube>(SceneCaptureComponent))
{
SceneCaptureComponentCube->CaptureScene();
}
}
}
return FReply::Handled();
})
[
SNew(STextBlock)
.Font(IDetailLayoutBuilder::GetDetailFont())
.Text(RenderCaptureText)
]
]
];
}
}
ECheckBoxState FSceneCaptureDetails::OnGetDisplayCheckState(FString ShowFlagName) const
{
TArray<const void*> RawData;
ShowFlagSettingsProperty->AccessRawData(RawData);
TArray<UObject*> OuterObjects;
ShowFlagSettingsProperty->GetOuterObjects(OuterObjects);
ECheckBoxState ReturnState = ECheckBoxState::Unchecked;
bool bReturnStateSet = false;
for (int32 ObjectIdx = 0; ObjectIdx < RawData.Num(); ++ObjectIdx)
{
const void* Data = RawData[ObjectIdx];
// Data can be nullptr when the SceneCapture is removed while its details are visible
if (!Data)
{
return ECheckBoxState::Unchecked;
}
const TArray<FEngineShowFlagsSetting>& ShowFlagSettings = *reinterpret_cast<const TArray<FEngineShowFlagsSetting>*>(Data);
const FEngineShowFlagsSetting* Setting = ShowFlagSettings.FindByPredicate([&ShowFlagName](const FEngineShowFlagsSetting& S) { return S.ShowFlagName == ShowFlagName; });
ECheckBoxState ThisObjectState = ECheckBoxState::Unchecked;
if (Setting)
{
ThisObjectState = Setting->Enabled ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}
else
{
const UObject* SceneComp = OuterObjects[ObjectIdx];
const USceneCaptureComponent* SceneCompArchetype = SceneComp ? Cast<USceneCaptureComponent>(SceneComp->GetArchetype()) : nullptr;
const int32 SettingIndex = SceneCompArchetype ? SceneCompArchetype->ShowFlags.FindIndexByName(*ShowFlagName) : INDEX_NONE;
if (SettingIndex != INDEX_NONE)
{
ThisObjectState = SceneCompArchetype->ShowFlags.GetSingleFlag(SettingIndex) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}
}
if (bReturnStateSet)
{
if (ThisObjectState != ReturnState)
{
ReturnState = ECheckBoxState::Undetermined;
break;
}
}
else
{
ReturnState = ThisObjectState;
bReturnStateSet = true;
}
}
return ReturnState;
}
void FSceneCaptureDetails::OnShowFlagCheckStateChanged(ECheckBoxState InNewRadioState, FString FlagName)
{
if (InNewRadioState == ECheckBoxState::Undetermined)
{
return;
}
FScopedTransaction Transaction(LOCTEXT("ShowFlagCheckStateChanged", "Show Flag Check State Changed"));
ShowFlagSettingsProperty->NotifyPreChange();
TArray<void*> RawData;
ShowFlagSettingsProperty->AccessRawData(RawData);
TArray<UObject*> OuterObjects;
ShowFlagSettingsProperty->GetOuterObjects(OuterObjects);
const bool bNewEnabledState = (InNewRadioState == ECheckBoxState::Checked) ? true : false;
for (int32 ObjectIdx = 0; ObjectIdx < RawData.Num(); ++ObjectIdx)
{
void* Data = RawData[ObjectIdx];
check(Data);
USceneCaptureComponent* SceneComp = Cast<USceneCaptureComponent>(OuterObjects[ObjectIdx]);
const USceneCaptureComponent* SceneCompArchetype = SceneComp ? Cast<USceneCaptureComponent>(SceneComp->GetArchetype()) : nullptr;
const bool bDefaultValue = UE::DetailsCustomization::Private::GetShowFlagState(SceneCompArchetype, FlagName);
TArray<FEngineShowFlagsSetting>& ShowFlagSettings = *reinterpret_cast<TArray<FEngineShowFlagsSetting>*>(Data);
if (bNewEnabledState == bDefaultValue)
{
// Just remove settings that are the same as defaults. This lets the flags return to their default state
ShowFlagSettings.RemoveAll([&FlagName](const FEngineShowFlagsSetting& Setting) { return Setting.ShowFlagName == FlagName; });
}
else
{
FEngineShowFlagsSetting* Setting = ShowFlagSettings.FindByPredicate([&FlagName](const FEngineShowFlagsSetting& S) { return S.ShowFlagName == FlagName; });
if (Setting)
{
// If the setting exists already for some reason, update it
Setting->Enabled = bNewEnabledState;
}
else
{
// Otherwise create a new setting
FEngineShowFlagsSetting NewFlagSetting;
NewFlagSetting.ShowFlagName = FlagName;
NewFlagSetting.Enabled = bNewEnabledState;
ShowFlagSettings.Add(NewFlagSetting);
}
}
UE::DetailsCustomization::Private::UpdateArchetypeChainShowFlagSettings(SceneComp, FlagName, bNewEnabledState);
}
ShowFlagSettingsProperty->NotifyPostChange(EPropertyChangeType::ValueSet);
ShowFlagSettingsProperty->NotifyFinishedChangingProperties();
}
bool FSceneCaptureDetails::GetShowFlagResetVisibility(FString ShowFlagName) const
{
TArray<UObject*> OuterObjects;
ShowFlagSettingsProperty->GetOuterObjects(OuterObjects);
for (UObject* OuterObject : OuterObjects)
{
if (const USceneCaptureComponent* SceneCaptureComponent = Cast<USceneCaptureComponent>(OuterObject))
{
if (const USceneCaptureComponent* SceneCompArchetype = Cast<USceneCaptureComponent>(SceneCaptureComponent->GetArchetype()))
{
return UE::DetailsCustomization::Private::GetShowFlagState(SceneCaptureComponent, ShowFlagName) != UE::DetailsCustomization::Private::GetShowFlagState(SceneCompArchetype, ShowFlagName);
}
}
}
return false;
}
void FSceneCaptureDetails::OnResetShowFlag(FString ShowFlagName)
{
FScopedTransaction Transaction(LOCTEXT("OnResetShowFlag", "On Reset Show Flag"));
FProperty* ShowFlagsSettingsPropertyVariable = FindFieldChecked<FProperty>(USceneCaptureComponent::StaticClass(), GET_MEMBER_NAME_CHECKED(USceneCaptureComponent, ShowFlagSettings));
FPropertyChangedEvent PropertyChangedEvent(ShowFlagsSettingsPropertyVariable);
ShowFlagSettingsProperty->NotifyPreChange();
TArray<void*> RawData;
ShowFlagSettingsProperty->AccessRawData(RawData);
TArray<UObject*> OuterObjects;
ShowFlagSettingsProperty->GetOuterObjects(OuterObjects);
for (int32 ObjectIdx = 0; ObjectIdx < RawData.Num(); ++ObjectIdx)
{
void* Data = RawData[ObjectIdx];
check(Data);
if (USceneCaptureComponent* SceneCaptureComponent = Cast<USceneCaptureComponent>(OuterObjects[ObjectIdx]))
{
// Reset to archetype default
TArray<FEngineShowFlagsSetting>& ShowFlagSettings = *reinterpret_cast<TArray<FEngineShowFlagsSetting>*>(Data);
ShowFlagSettings.RemoveAll([&ShowFlagName](const FEngineShowFlagsSetting& InSetting)
{
return InSetting.ShowFlagName.Equals(ShowFlagName);
});
const USceneCaptureComponent* SceneCompArchetype = Cast<USceneCaptureComponent>(SceneCaptureComponent->GetArchetype());
const bool bDefaultValue = UE::DetailsCustomization::Private::GetShowFlagState(SceneCompArchetype, ShowFlagName);
UE::DetailsCustomization::Private::UpdateArchetypeChainShowFlagSettings(SceneCaptureComponent, ShowFlagName, bDefaultValue);
}
}
ShowFlagSettingsProperty->NotifyPostChange(EPropertyChangeType::ValueSet);
ShowFlagSettingsProperty->NotifyFinishedChangingProperties();
}
#undef LOCTEXT_NAMESPACE