533 lines
24 KiB
C++
533 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "SCommonEditorViewportToolbarBase.h"
|
|
#include "Widgets/SBoxPanel.h"
|
|
#include "Widgets/Layout/SBorder.h"
|
|
#include "Widgets/Layout/SBox.h"
|
|
#include "Widgets/Input/SSpinBox.h"
|
|
#include "EditorStyleSet.h"
|
|
|
|
#include "STransformViewportToolbar.h"
|
|
#include "EditorShowFlags.h"
|
|
#include "SEditorViewport.h"
|
|
#include "EditorViewportCommands.h"
|
|
#include "SEditorViewportToolBarMenu.h"
|
|
#include "SEditorViewportToolBarButton.h"
|
|
#include "SEditorViewportViewMenu.h"
|
|
#include "Editor/EditorPerformanceSettings.h"
|
|
#include "Scalability.h"
|
|
#include "SScalabilitySettings.h"
|
|
#include "AssetEditorViewportLayout.h"
|
|
#include "SAssetEditorViewport.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "SCommonEditorViewportToolbarBase"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// SCommonEditorViewportToolbarBase
|
|
|
|
void SCommonEditorViewportToolbarBase::Construct(const FArguments& InArgs, TSharedPtr<class ICommonEditorViewportToolbarInfoProvider> InInfoProvider)
|
|
{
|
|
InfoProviderPtr = InInfoProvider;
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
TSharedPtr<SHorizontalBox> MainBoxPtr;
|
|
|
|
const FMargin ToolbarSlotPadding(2.0f, 2.0f);
|
|
const FMargin ToolbarButtonPadding(2.0f, 0.0f);
|
|
|
|
static const FName DefaultForegroundName("DefaultForeground");
|
|
|
|
ChildSlot
|
|
[SNew(SBorder)
|
|
.BorderImage(FEditorStyle::GetBrush("NoBorder"))
|
|
// Color and opacity is changed based on whether or not the mouse cursor is hovering over the toolbar area
|
|
.ColorAndOpacity(this, &SViewportToolBar::OnGetColorAndOpacity)
|
|
.ForegroundColor(FEditorStyle::GetSlateColor(DefaultForegroundName))
|
|
[SNew(SVerticalBox) + SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[SAssignNew(MainBoxPtr, SHorizontalBox)]]];
|
|
|
|
// Options menu
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[SNew(SEditorViewportToolbarMenu)
|
|
.ParentToolBar(SharedThis(this))
|
|
.Cursor(EMouseCursor::Default)
|
|
.Image("EditorViewportToolBar.MenuDropdown")
|
|
.OnGetMenuContent(this, &SCommonEditorViewportToolbarBase::GenerateOptionsMenu)];
|
|
|
|
// Camera mode menu
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[SNew(SEditorViewportToolbarMenu)
|
|
.ParentToolBar(SharedThis(this))
|
|
.Cursor(EMouseCursor::Default)
|
|
.Label(this, &SCommonEditorViewportToolbarBase::GetCameraMenuLabel)
|
|
.LabelIcon(this, &SCommonEditorViewportToolbarBase::GetCameraMenuLabelIcon)
|
|
.OnGetMenuContent(this, &SCommonEditorViewportToolbarBase::GenerateCameraMenu)];
|
|
|
|
// View menu
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[MakeViewMenu()];
|
|
|
|
// Show menu
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[SNew(SEditorViewportToolbarMenu)
|
|
.Label(LOCTEXT("ShowMenuTitle", "Show"))
|
|
.Cursor(EMouseCursor::Default)
|
|
.ParentToolBar(SharedThis(this))
|
|
.OnGetMenuContent(this, &SCommonEditorViewportToolbarBase::GenerateShowMenu)];
|
|
|
|
// Realtime button
|
|
if (InArgs._AddRealtimeButton)
|
|
{
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[SNew(SEditorViewportToolBarButton)
|
|
.Cursor(EMouseCursor::Default)
|
|
.ButtonType(EUserInterfaceActionType::Button)
|
|
.ButtonStyle(&FEditorStyle::Get().GetWidgetStyle<FButtonStyle>("EditorViewportToolBar.MenuButtonWarning"))
|
|
.OnClicked(this, &SCommonEditorViewportToolbarBase::OnRealtimeWarningClicked)
|
|
.Visibility(this, &SCommonEditorViewportToolbarBase::GetRealtimeWarningVisibility)
|
|
.ToolTipText(LOCTEXT("RealtimeOff_ToolTip", "This viewport is not updating in realtime. Click to turn on realtime mode."))
|
|
.Content()
|
|
[SNew(STextBlock)
|
|
.Font(FEditorStyle::GetFontStyle("EditorViewportToolBar.Font"))
|
|
.Text(LOCTEXT("RealtimeOff", "Realtime: Off"))
|
|
.ColorAndOpacity(FLinearColor::Black)]];
|
|
}
|
|
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[SNew(SEditorViewportToolbarMenu)
|
|
.Label(LOCTEXT("ViewParamMenuTitle", "View Mode Options"))
|
|
.Cursor(EMouseCursor::Default)
|
|
.ParentToolBar(SharedThis(this))
|
|
.Visibility(this, &SCommonEditorViewportToolbarBase::GetViewModeOptionsVisibility)
|
|
.OnGetMenuContent(this, &SCommonEditorViewportToolbarBase::GenerateViewModeOptionsMenu)];
|
|
|
|
MainBoxPtr->AddSlot()
|
|
.AutoWidth()
|
|
.Padding(ToolbarSlotPadding)
|
|
[
|
|
// Button to show scalability warnings
|
|
SNew(SEditorViewportToolbarMenu)
|
|
.ParentToolBar(SharedThis(this))
|
|
.Cursor(EMouseCursor::Default)
|
|
.Label(this, &SCommonEditorViewportToolbarBase::GetScalabilityWarningLabel)
|
|
.MenuStyle(FEditorStyle::Get(), "EditorViewportToolBar.MenuButtonWarning")
|
|
.OnGetMenuContent(this, &SCommonEditorViewportToolbarBase::GetScalabilityWarningMenuContent)
|
|
.Visibility(this, &SCommonEditorViewportToolbarBase::GetScalabilityWarningVisibility)
|
|
.ToolTipText(LOCTEXT("ScalabilityWarning_ToolTip", "Non-default scalability settings could be affecting what is shown in this viewport.\nFor example you may experience lower visual quality, reduced particle counts, and other artifacts that don't match what the scene would look like when running outside of the editor. Click to make changes."))];
|
|
|
|
// Add optional toolbar slots to be added by child classes inherited from this common viewport toolbar
|
|
ExtendLeftAlignedToolbarSlots(MainBoxPtr, SharedThis(this));
|
|
|
|
// Transform toolbar
|
|
MainBoxPtr->AddSlot()
|
|
.Padding(ToolbarSlotPadding)
|
|
.HAlign(HAlign_Right)
|
|
[SNew(STransformViewportToolBar)
|
|
.Viewport(ViewportRef)
|
|
.CommandList(ViewportRef->GetCommandList())
|
|
.Extenders(GetInfoProvider().GetExtenders())
|
|
.Visibility(ViewportRef, &SEditorViewport::GetTransformToolbarVisibility)];
|
|
|
|
SViewportToolBar::Construct(SViewportToolBar::FArguments());
|
|
}
|
|
|
|
FText SCommonEditorViewportToolbarBase::GetCameraMenuLabel() const
|
|
{
|
|
return GetCameraMenuLabelFromViewportType(GetViewportClient().GetViewportType());
|
|
}
|
|
|
|
const FSlateBrush* SCommonEditorViewportToolbarBase::GetCameraMenuLabelIcon() const
|
|
{
|
|
return GetCameraMenuLabelIconFromViewportType(GetViewportClient().GetViewportType());
|
|
}
|
|
|
|
EVisibility SCommonEditorViewportToolbarBase::GetViewModeOptionsVisibility() const
|
|
{
|
|
const FEditorViewportClient& ViewClient = GetViewportClient();
|
|
if (ViewClient.GetViewMode() == VMI_MeshUVDensityAccuracy || ViewClient.GetViewMode() == VMI_MaterialTextureScaleAccuracy || ViewClient.GetViewMode() == VMI_RequiredTextureResolution)
|
|
{
|
|
return EVisibility::SelfHitTestInvisible;
|
|
}
|
|
else
|
|
{
|
|
return EVisibility::Collapsed;
|
|
}
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateViewModeOptionsMenu() const
|
|
{
|
|
GetInfoProvider().OnFloatingButtonClicked();
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
FEditorViewportClient& ViewClient = GetViewportClient();
|
|
const UWorld* World = ViewClient.GetWorld();
|
|
return BuildViewModeOptionsMenu(ViewportRef->GetCommandList(), ViewClient.GetViewMode(), World ? World->FeatureLevel.GetValue() : GMaxRHIFeatureLevel, ViewClient.GetViewModeParamNameMap());
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateOptionsMenu() const
|
|
{
|
|
GetInfoProvider().OnFloatingButtonClicked();
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
|
|
const bool bIsPerspective = GetViewportClient().GetViewportType() == LVT_Perspective;
|
|
|
|
const bool bInShouldCloseWindowAfterMenuSelection = true;
|
|
FMenuBuilder OptionsMenuBuilder(bInShouldCloseWindowAfterMenuSelection, ViewportRef->GetCommandList());
|
|
{
|
|
OptionsMenuBuilder.BeginSection("LevelViewportViewportOptions", LOCTEXT("OptionsMenuHeader", "Viewport Options"));
|
|
{
|
|
OptionsMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().ToggleRealTime);
|
|
OptionsMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().ToggleStats);
|
|
OptionsMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().ToggleFPS);
|
|
|
|
if (bIsPerspective)
|
|
{
|
|
OptionsMenuBuilder.AddWidget(GenerateFOVMenu(), LOCTEXT("FOVAngle", "Field of View (H)"));
|
|
OptionsMenuBuilder.AddWidget(GenerateFarViewPlaneMenu(), LOCTEXT("FarViewPlane", "Far View Plane"));
|
|
}
|
|
|
|
OptionsMenuBuilder.AddWidget(GenerateScreenPercentageMenu(), LOCTEXT("ScreenPercentage", "Screen Percentage"));
|
|
}
|
|
OptionsMenuBuilder.EndSection();
|
|
|
|
TSharedPtr<SAssetEditorViewport> AssetEditorViewportPtr = StaticCastSharedRef<SAssetEditorViewport>(ViewportRef);
|
|
if (AssetEditorViewportPtr.IsValid())
|
|
{
|
|
OptionsMenuBuilder.BeginSection("EditorViewportLayouts");
|
|
{
|
|
OptionsMenuBuilder.AddSubMenu(
|
|
LOCTEXT("ConfigsSubMenu", "Layouts"),
|
|
FText::GetEmpty(),
|
|
FNewMenuDelegate::CreateSP(AssetEditorViewportPtr.Get(), &SAssetEditorViewport::GenerateLayoutMenu));
|
|
}
|
|
OptionsMenuBuilder.EndSection();
|
|
}
|
|
|
|
ExtendOptionsMenu(OptionsMenuBuilder);
|
|
}
|
|
|
|
return OptionsMenuBuilder.MakeWidget();
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateCameraMenu() const
|
|
{
|
|
GetInfoProvider().OnFloatingButtonClicked();
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
|
|
const bool bInShouldCloseWindowAfterMenuSelection = true;
|
|
FMenuBuilder CameraMenuBuilder(bInShouldCloseWindowAfterMenuSelection, ViewportRef->GetCommandList());
|
|
|
|
// Camera types
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Perspective);
|
|
|
|
CameraMenuBuilder.BeginSection("LevelViewportCameraType_Ortho", LOCTEXT("CameraTypeHeader_Ortho", "Orthographic"));
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Top);
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Bottom);
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Left);
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Right);
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Front);
|
|
CameraMenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().Back);
|
|
CameraMenuBuilder.EndSection();
|
|
|
|
return CameraMenuBuilder.MakeWidget();
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateShowMenu() const
|
|
{
|
|
GetInfoProvider().OnFloatingButtonClicked();
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
|
|
#if 0
|
|
const FLevelViewportCommands& Actions = FLevelViewportCommands::Get();
|
|
|
|
const TArray<FShowFlagData>& ShowFlagData = GetShowFlagMenuItems();
|
|
|
|
TArray<CommonEditorViewportUtils::FShowMenuCommand> ShowMenu[SFG_Max];
|
|
|
|
// Get each show flag command and put them in their corresponding groups
|
|
for( int32 ShowFlag = 0; ShowFlag < ShowFlagData.Num(); ++ShowFlag )
|
|
{
|
|
const FShowFlagData& SFData = ShowFlagData[ShowFlag];
|
|
|
|
ShowMenu[SFData.Group].Add( Actions.ShowFlagCommands[ ShowFlag ] );
|
|
}
|
|
#endif
|
|
|
|
const bool bInShouldCloseWindowAfterMenuSelection = true;
|
|
FMenuBuilder ShowMenuBuilder(bInShouldCloseWindowAfterMenuSelection, ViewportRef->GetCommandList());
|
|
{
|
|
|
|
#if 0
|
|
ShowMenuBuilder.AddMenuEntry( Actions.UseDefaultShowFlags );
|
|
|
|
if( ShowMenu[SFG_Normal].Num() > 0 )
|
|
{
|
|
// Generate entries for the standard show flags
|
|
ShowMenuBuilder.BeginSection("LevelViewportShowFlagsCommon", LOCTEXT("CommonShowFlagHeader", "Common Show Flags") );
|
|
{
|
|
for( int32 EntryIndex = 0; EntryIndex < ShowMenu[SFG_Normal].Num(); ++EntryIndex )
|
|
{
|
|
ShowMenuBuilder.AddMenuEntry( ShowMenu[SFG_Normal][ EntryIndex ].ShowMenuItem, NAME_None, ShowMenu[SFG_Normal][ EntryIndex ].LabelOverride );
|
|
}
|
|
}
|
|
ShowMenuBuilder.EndSection();
|
|
}
|
|
|
|
// Generate entries for the different show flags groups
|
|
ShowMenuBuilder.BeginSection("LevelViewportShowFlags");
|
|
{
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("PostProcessShowFlagsMenu", "Post Processing"), LOCTEXT("PostProcessShowFlagsMenu_ToolTip", "Post process show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_PostProcess], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("LightTypesShowFlagsMenu", "Light Types"), LOCTEXT("LightTypesShowFlagsMenu_ToolTip", "Light Types show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_LightTypes], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("LightingComponentsShowFlagsMenu", "Lighting Components"), LOCTEXT("LightingComponentsShowFlagsMenu_ToolTip", "Lighting Components show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_LightingComponents], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("LightingFeaturesShowFlagsMenu", "Lighting Features"), LOCTEXT("LightingFeaturesShowFlagsMenu_ToolTip", "Lighting Features show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_LightingFeatures], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("DeveloperShowFlagsMenu", "Developer"), LOCTEXT("DeveloperShowFlagsMenu_ToolTip", "Developer show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_Developer], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("VisualizeShowFlagsMenu", "Visualize"), LOCTEXT("VisualizeShowFlagsMenu_ToolTip", "Visualize show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_Visualize], 0));
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("AdvancedShowFlagsMenu", "Advanced"), LOCTEXT("AdvancedShowFlagsMenu_ToolTip", "Advanced show flags"),
|
|
FNewMenuDelegate::CreateStatic(&CommonEditorViewportUtils::FillShowMenu, ShowMenu[SFG_Advanced], 0));
|
|
}
|
|
ShowMenuBuilder.EndSection();
|
|
|
|
|
|
FText ShowAllLabel = LOCTEXT("ShowAllLabel", "Show All");
|
|
FText HideAllLabel = LOCTEXT("HideAllLabel", "Hide All");
|
|
|
|
// Show Volumes sub-menu
|
|
{
|
|
TArray< FLevelViewportCommands::FShowMenuCommand > ShowVolumesMenu;
|
|
|
|
// 'Show All' and 'Hide All' buttons
|
|
ShowVolumesMenu.Add( FLevelViewportCommands::FShowMenuCommand( Actions.ShowAllVolumes, ShowAllLabel ) );
|
|
ShowVolumesMenu.Add( FLevelViewportCommands::FShowMenuCommand( Actions.HideAllVolumes, HideAllLabel ) );
|
|
|
|
// Get each show flag command and put them in their corresponding groups
|
|
ShowVolumesMenu += Actions.ShowVolumeCommands;
|
|
|
|
ShowMenuBuilder.AddSubMenu( LOCTEXT("ShowVolumesMenu", "Volumes"), LOCTEXT("ShowVolumesMenu_ToolTip", "Show volumes flags"),
|
|
FNewMenuDelegate::CreateStatic( &FillShowMenu, ShowVolumesMenu, 2 ) );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return ShowMenuBuilder.MakeWidget();
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateFOVMenu() const
|
|
{
|
|
const float FOVMin = 5.f;
|
|
const float FOVMax = 170.f;
|
|
|
|
return SNew(SBox)
|
|
.HAlign(HAlign_Right)
|
|
[SNew(SBox)
|
|
.Padding(FMargin(4.0f, 0.0f, 0.0f, 0.0f))
|
|
.WidthOverride(100.0f)
|
|
[SNew(SSpinBox<float>)
|
|
.Font(FEditorStyle::GetFontStyle(TEXT("MenuItem.Font")))
|
|
.MinValue(FOVMin)
|
|
.MaxValue(FOVMax)
|
|
.Value(this, &SCommonEditorViewportToolbarBase::OnGetFOVValue)
|
|
.OnValueChanged(this, &SCommonEditorViewportToolbarBase::OnFOVValueChanged)]];
|
|
}
|
|
|
|
float SCommonEditorViewportToolbarBase::OnGetFOVValue() const
|
|
{
|
|
return GetViewportClient().ViewFOV;
|
|
}
|
|
|
|
void SCommonEditorViewportToolbarBase::OnFOVValueChanged(float NewValue) const
|
|
{
|
|
FEditorViewportClient& ViewportClient = GetViewportClient();
|
|
ViewportClient.FOVAngle = NewValue;
|
|
ViewportClient.ViewFOV = NewValue;
|
|
ViewportClient.Invalidate();
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateScreenPercentageMenu() const
|
|
{
|
|
const int32 PreviewScreenPercentageMin = FSceneViewScreenPercentageConfig::kMinTAAUpsampleResolutionFraction * 100.0f;
|
|
const int32 PreviewScreenPercentageMax = FSceneViewScreenPercentageConfig::kMaxTAAUpsampleResolutionFraction * 100.0f;
|
|
|
|
return SNew(SBox)
|
|
.HAlign(HAlign_Right)
|
|
.IsEnabled(this, &SCommonEditorViewportToolbarBase::OnScreenPercentageIsEnabled)
|
|
[SNew(SBox)
|
|
.Padding(FMargin(4.0f, 0.0f, 0.0f, 0.0f))
|
|
.WidthOverride(100.0f)
|
|
[SNew(SSpinBox<int32>)
|
|
.Font(FEditorStyle::GetFontStyle(TEXT("MenuItem.Font")))
|
|
.MinValue(PreviewScreenPercentageMin)
|
|
.MaxValue(PreviewScreenPercentageMax)
|
|
.Value(this, &SCommonEditorViewportToolbarBase::OnGetScreenPercentageValue)
|
|
.OnValueChanged(const_cast<SCommonEditorViewportToolbarBase*>(this), &SCommonEditorViewportToolbarBase::OnScreenPercentageValueChanged)]];
|
|
}
|
|
|
|
int32 SCommonEditorViewportToolbarBase::OnGetScreenPercentageValue() const
|
|
{
|
|
return GetViewportClient().GetPreviewScreenPercentage();
|
|
}
|
|
|
|
bool SCommonEditorViewportToolbarBase::OnScreenPercentageIsEnabled() const
|
|
{
|
|
return GetViewportClient().SupportsPreviewResolutionFraction();
|
|
}
|
|
|
|
void SCommonEditorViewportToolbarBase::OnScreenPercentageValueChanged(int32 NewValue)
|
|
{
|
|
FEditorViewportClient& ViewportClient = GetViewportClient();
|
|
ViewportClient.SetPreviewScreenPercentage(NewValue);
|
|
ViewportClient.Invalidate();
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GenerateFarViewPlaneMenu() const
|
|
{
|
|
return SNew(SBox)
|
|
.HAlign(HAlign_Right)
|
|
[SNew(SBox)
|
|
.Padding(FMargin(4.0f, 0.0f, 0.0f, 0.0f))
|
|
.WidthOverride(100.0f)
|
|
[SNew(SSpinBox<float>)
|
|
.ToolTipText(LOCTEXT("FarViewPlaneTooltip", "Distance to use as the far view plane, or zero to enable an infinite far view plane"))
|
|
.MinValue(0.0f)
|
|
.MaxValue(100000.0f)
|
|
.Font(FEditorStyle::GetFontStyle(TEXT("MenuItem.Font")))
|
|
.Value(this, &SCommonEditorViewportToolbarBase::OnGetFarViewPlaneValue)
|
|
.OnValueChanged(const_cast<SCommonEditorViewportToolbarBase*>(this), &SCommonEditorViewportToolbarBase::OnFarViewPlaneValueChanged)]];
|
|
}
|
|
|
|
float SCommonEditorViewportToolbarBase::OnGetFarViewPlaneValue() const
|
|
{
|
|
return GetViewportClient().GetFarClipPlaneOverride();
|
|
}
|
|
|
|
void SCommonEditorViewportToolbarBase::OnFarViewPlaneValueChanged(float NewValue)
|
|
{
|
|
GetViewportClient().OverrideFarClipPlane(NewValue);
|
|
}
|
|
|
|
FReply SCommonEditorViewportToolbarBase::OnRealtimeWarningClicked()
|
|
{
|
|
FEditorViewportClient& ViewportClient = GetViewportClient();
|
|
ViewportClient.SetRealtime(true);
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
EVisibility SCommonEditorViewportToolbarBase::GetRealtimeWarningVisibility() const
|
|
{
|
|
FEditorViewportClient& ViewportClient = GetViewportClient();
|
|
// If the viewport is not realtime and there is no override then realtime is off
|
|
return !ViewportClient.IsRealtime() && !ViewportClient.IsRealtimeOverrideSet() ? EVisibility::Visible : EVisibility::Collapsed;
|
|
}
|
|
|
|
TSharedPtr<FExtender> SCommonEditorViewportToolbarBase::GetCombinedExtenderList(TSharedRef<FExtender> MenuExtender) const
|
|
{
|
|
TSharedPtr<FExtender> HostEditorExtenders = GetInfoProvider().GetExtenders();
|
|
|
|
TArray<TSharedPtr<FExtender>> Extenders;
|
|
Extenders.Reserve(2);
|
|
Extenders.Add(HostEditorExtenders);
|
|
Extenders.Add(MenuExtender);
|
|
|
|
return FExtender::Combine(Extenders);
|
|
}
|
|
|
|
TSharedPtr<FExtender> SCommonEditorViewportToolbarBase::GetViewMenuExtender() const
|
|
{
|
|
TSharedRef<FExtender> ViewModeExtender(new FExtender());
|
|
ViewModeExtender->AddMenuExtension(
|
|
TEXT("ViewMode"),
|
|
EExtensionHook::After,
|
|
GetInfoProvider().GetViewportWidget()->GetCommandList(),
|
|
FMenuExtensionDelegate::CreateSP(const_cast<SCommonEditorViewportToolbarBase*>(this), &SCommonEditorViewportToolbarBase::CreateViewMenuExtensions));
|
|
|
|
return GetCombinedExtenderList(ViewModeExtender);
|
|
}
|
|
|
|
void SCommonEditorViewportToolbarBase::CreateViewMenuExtensions(FMenuBuilder& MenuBuilder)
|
|
{
|
|
MenuBuilder.BeginSection("LevelViewportDeferredRendering", LOCTEXT("DeferredRenderingHeader", "Deferred Rendering"));
|
|
MenuBuilder.EndSection();
|
|
|
|
MenuBuilder.BeginSection("LevelViewportCollision", LOCTEXT("CollisionViewModeHeader", "Collision"));
|
|
{
|
|
MenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().CollisionPawn, NAME_None, LOCTEXT("CollisionPawnViewModeDisplayName", "Player Collision"));
|
|
MenuBuilder.AddMenuEntry(FEditorViewportCommands::Get().CollisionVisibility, NAME_None, LOCTEXT("CollisionVisibilityViewModeDisplayName", "Visibility Collision"));
|
|
}
|
|
MenuBuilder.EndSection();
|
|
|
|
// FINDME
|
|
// MenuBuilder.BeginSection("LevelViewportLandscape", LOCTEXT("LandscapeHeader", "Landscape") );
|
|
// {
|
|
// MenuBuilder.AddSubMenu(LOCTEXT("LandscapeLODDisplayName", "LOD"), LOCTEXT("LandscapeLODMenu_ToolTip", "Override Landscape LOD in this viewport"), FNewMenuDelegate::CreateStatic(&Local::BuildLandscapeLODMenu, this), /*Default*/false, FSlateIcon());
|
|
// }
|
|
// MenuBuilder.EndSection();
|
|
}
|
|
|
|
ICommonEditorViewportToolbarInfoProvider& SCommonEditorViewportToolbarBase::GetInfoProvider() const
|
|
{
|
|
return *InfoProviderPtr.Pin().Get();
|
|
}
|
|
|
|
FEditorViewportClient& SCommonEditorViewportToolbarBase::GetViewportClient() const
|
|
{
|
|
return *GetInfoProvider().GetViewportWidget()->GetViewportClient().Get();
|
|
}
|
|
|
|
TSharedRef<SEditorViewportViewMenu> SCommonEditorViewportToolbarBase::MakeViewMenu()
|
|
{
|
|
TSharedRef<SEditorViewport> ViewportRef = GetInfoProvider().GetViewportWidget();
|
|
|
|
return SNew(SEditorViewportViewMenu, ViewportRef, SharedThis(this))
|
|
.Cursor(EMouseCursor::Default)
|
|
.MenuExtenders(GetViewMenuExtender());
|
|
}
|
|
|
|
FText SCommonEditorViewportToolbarBase::GetScalabilityWarningLabel() const
|
|
{
|
|
const int32 QualityLevel = Scalability::GetQualityLevels().GetMinQualityLevel();
|
|
if (QualityLevel >= 0)
|
|
{
|
|
return FText::Format(LOCTEXT("ScalabilityWarning", "Scalability: {0}"), Scalability::GetScalabilityNameFromQualityLevel(QualityLevel));
|
|
}
|
|
|
|
return FText::GetEmpty();
|
|
}
|
|
|
|
EVisibility SCommonEditorViewportToolbarBase::GetScalabilityWarningVisibility() const
|
|
{
|
|
// This method returns magic numbers. 3 means epic
|
|
return GetDefault<UEditorPerformanceSettings>()->bEnableScalabilityWarningIndicator && GetShowScalabilityMenu() && Scalability::GetQualityLevels().GetMinQualityLevel() < 3 ? EVisibility::Visible : EVisibility::Collapsed;
|
|
}
|
|
|
|
TSharedRef<SWidget> SCommonEditorViewportToolbarBase::GetScalabilityWarningMenuContent() const
|
|
{
|
|
return SNew(SBorder)
|
|
.BorderImage(FEditorStyle::GetBrush("Menu.Background"))
|
|
[SNew(SScalabilitySettings)];
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|