izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
636abcceeea416da4706765c94de29eab88e42fe
UnrealEngineUWP/Engine/Source/Editor/LandscapeEditor/Private/LandscapeEditorDetails.cpp
Lauren Barnes 6248f8d412 Replacing legacy EditorStyle calls with AppStyle 
#preflight 6272a74d2f6d177be3c6fdda
#rb Matt.Kuhlenschmidt

#ROBOMERGE-OWNER: Lauren.Barnes
#ROBOMERGE-AUTHOR: lauren.barnes
#ROBOMERGE-SOURCE: CL 20057269 via CL 20070159 via CL 20072035 via CL 20072203
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v943-19904690)
#ROBOMERGE-CONFLICT from-shelf

[CL 20105363 by Lauren Barnes in ue5-main branch]
2022-05-09 13:12:28 -04:00

619 lines
27 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "LandscapeEditorDetails.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/MultiBox/MultiBoxDefs.h"
#include "Widgets/Text/STextBlock.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Input/SMultiLineEditableTextBox.h"
#include "Widgets/Input/SSpinBox.h"
#include "Widgets/Input/SSegmentedControl.h"
#include "LandscapeEdMode.h"
#include "LandscapeEditorDetailCustomization_NewLandscape.h"
#include "LandscapeEditorDetailCustomization_ResizeLandscape.h"
#include "LandscapeEditorDetailCustomization_CopyPaste.h"
#include "LandscapeEditorDetailCustomization_MiscTools.h"
#include "LandscapeEditorDetailCustomization_AlphaBrush.h"
#include "LandscapeEditorDetailCustomization_ImportExport.h"
#include "DetailWidgetRow.h"
#include "LandscapeEditorDetailCustomization_TargetLayers.h"
#include "DetailCategoryBuilder.h"
#include "DetailLayoutBuilder.h"
#include "Editor/PropertyEditor/Public/VariablePrecisionNumericInterface.h"
#include "Templates/SharedPointer.h"
#include "SLandscapeEditor.h"
#include "LandscapeEditorCommands.h"
#include "LandscapeEditorDetailWidgets.h"
#include "LandscapeEditorDetailCustomization_LayersBrushStack.h"
#include "LandscapeEditorObject.h"
#include "Landscape.h"
#define LOCTEXT_NAMESPACE "LandscapeEditor"
TSharedRef<IDetailCustomization> FLandscapeEditorDetails::MakeInstance()
{
return MakeShareable(new FLandscapeEditorDetails);
}
void FLandscapeEditorDetails::CustomizeDetails(IDetailLayoutBuilder& DetailBuilder)
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
CommandList = LandscapeEdMode->GetUICommandList();
static const FLinearColor BorderColor = FLinearColor(0.2f, 0.2f, 0.2f, 0.2f);
static const FSlateBrush* BorderStyle = FAppStyle::GetBrush("DetailsView.GroupSection");
IDetailCategoryBuilder& LandscapeEditorCategory = DetailBuilder.EditCategory("LandscapeEditor", NSLOCTEXT("Contexts", "LandscapeEditor", "Landscape Editor"), ECategoryPriority::TypeSpecific);
LandscapeEditorCategory.AddCustomRow(FText::GetEmpty())
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateStatic(&FLandscapeEditorDetails::GetTargetLandscapeSelectorVisibility)))
[
SNew(SComboButton)
.OnGetMenuContent_Static(&FLandscapeEditorDetails::GetTargetLandscapeMenu)
.ButtonContent()
[
SNew(STextBlock)
.Text_Static(&FLandscapeEditorDetails::GetTargetLandscapeName)
]
];
FText Reason;
bool bDisabledEditing = LandscapeEdMode->CurrentToolTarget.LandscapeInfo.IsValid() && !LandscapeEdMode->CanEditCurrentTarget(&Reason);
if (bDisabledEditing)
{
LandscapeEditorCategory.AddCustomRow(FText::GetEmpty())
[
SNew(SMultiLineEditableTextBox)
.IsReadOnly(true)
.AutoWrapText(true)
.Font(FCoreStyle::GetDefaultFontStyle("Bold", 10))
.Justification(ETextJustify::Center)
.BackgroundColor(FCoreStyle::Get().GetColor("ErrorReporting.BackgroundColor"))
.ForegroundColor(FCoreStyle::Get().GetColor("ErrorReporting.ForegroundColor"))
.Text(Reason)
];
}
// Only continue cuztomization if we are in NewLandscape mode or if editing is not disabled
if (bDisabledEditing && LandscapeEdMode->CurrentTool->GetToolName() != FName("NewLandscape"))
{
return;
}
// Custom Brush Selectors
TSharedPtr<SSegmentedControl<FName>> BrushSelectors = SNew(SSegmentedControl<FName>)
.OnValueChanged(this, &FLandscapeEditorDetails::SetBrushCommand)
.Value(this, &FLandscapeEditorDetails::GetCurrentBrushFName) ;
for (FName BrushName : LandscapeEdMode->CurrentTool->ValidBrushes)
{
TSharedPtr<FUICommandInfo> Command = FLandscapeEditorCommands::Get().NameToCommandMap.FindRef(BrushName);
if (Command.IsValid())
{
BrushSelectors->AddSlot(BrushName)
.Icon(Command->GetIcon().GetIcon())
.ToolTip(Command->GetDescription());
}
}
BrushSelectors->RebuildChildren();
TSharedPtr<SSegmentedControl<FName>> FalloffSelectors = SNew(SSegmentedControl<FName>)
.OnValueChanged(this, &FLandscapeEditorDetails::SetBrushCommand)
.Value(this, &FLandscapeEditorDetails::GetCurrentBrushFalloffFName)
+ SSegmentedControl<FName>::Slot(FName("Circle_Smooth")).Icon(FLandscapeEditorCommands::Get().CircleBrush_Smooth->GetIcon().GetIcon()).ToolTip(FLandscapeEditorCommands::Get().CircleBrush_Smooth->GetDescription())
+ SSegmentedControl<FName>::Slot(FName("Circle_Linear")).Icon(FLandscapeEditorCommands::Get().CircleBrush_Linear->GetIcon().GetIcon()).ToolTip(FLandscapeEditorCommands::Get().CircleBrush_Linear->GetDescription())
+ SSegmentedControl<FName>::Slot(FName("Circle_Spherical")).Icon(FLandscapeEditorCommands::Get().CircleBrush_Spherical->GetIcon().GetIcon()).ToolTip(FLandscapeEditorCommands::Get().CircleBrush_Spherical->GetDescription())
+ SSegmentedControl<FName>::Slot(FName("Circle_Tip")).Icon(FLandscapeEditorCommands::Get().CircleBrush_Tip->GetIcon().GetIcon()).ToolTip(FLandscapeEditorCommands::Get().CircleBrush_Tip->GetDescription());
LandscapeEditorCategory.AddCustomRow(FText::GetEmpty())
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FLandscapeEditorDetails::GetBrushSelectorVisibility)))
.NameContent()
[
SNew(STextBlock)
.TextStyle( &FCoreStyle::Get().GetWidgetStyle<FTextBlockStyle>( "SmallText" ) )
.Text(LOCTEXT("BrushSelector", "Brush Type"))
]
.ValueContent()
[
BrushSelectors.ToSharedRef()
];
LandscapeEditorCategory.AddCustomRow(FText::GetEmpty())
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FLandscapeEditorDetails::GetBrushFalloffSelectorVisibility)))
.NameContent()
[
SNew(STextBlock)
.TextStyle( &FCoreStyle::Get().GetWidgetStyle<FTextBlockStyle>( "SmallText" ) )
.Text(LOCTEXT("BrushFalloff", "Brush Falloff"))
]
.ValueContent()
[
FalloffSelectors.ToSharedRef()
];
// Tools:
Customization_NewLandscape = MakeShareable(new FLandscapeEditorDetailCustomization_NewLandscape);
Customization_NewLandscape->CustomizeDetails(DetailBuilder);
Customization_ImportExport = MakeShareable(new FLandscapeEditorDetailCustomization_ImportExport);
Customization_ImportExport->CustomizeDetails(DetailBuilder);
Customization_ResizeLandscape = MakeShareable(new FLandscapeEditorDetailCustomization_ResizeLandscape);
Customization_ResizeLandscape->CustomizeDetails(DetailBuilder);
Customization_CopyPaste = MakeShareable(new FLandscapeEditorDetailCustomization_CopyPaste);
Customization_CopyPaste->CustomizeDetails(DetailBuilder);
Customization_MiscTools = MakeShareable(new FLandscapeEditorDetailCustomization_MiscTools);
Customization_MiscTools->CustomizeDetails(DetailBuilder);
// Brushes:
Customization_AlphaBrush = MakeShareable(new FLandscapeEditorDetailCustomization_AlphaBrush);
Customization_AlphaBrush->CustomizeDetails(DetailBuilder);
if (LandscapeEdMode->CanHaveLandscapeLayersContent())
{
// Layers
Customization_Layers = MakeShareable(new FLandscapeEditorDetailCustomization_Layers);
Customization_Layers->CustomizeDetails(DetailBuilder);
// Brush Stack
Customization_LayersBrushStack = MakeShareable(new FLandscapeEditorDetailCustomization_LayersBrushStack);
Customization_LayersBrushStack->CustomizeDetails(DetailBuilder);
}
// Target Layers:
Customization_TargetLayers = MakeShareable(new FLandscapeEditorDetailCustomization_TargetLayers);
Customization_TargetLayers->CustomizeDetails(DetailBuilder);
}
FText FLandscapeEditorDetails::GetLocalizedName(FString Name)
{
static bool bInitialized = false;
if (!bInitialized)
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
bInitialized = true;
LOCTEXT("ToolSet_NewLandscape", "New Landscape");
LOCTEXT("ToolSet_ResizeLandscape", "Change Component Size");
LOCTEXT("ToolSet_Sculpt", "Sculpt");
LOCTEXT("ToolSet_Erase", "Erase");
LOCTEXT("ToolSet_Paint", "Paint");
LOCTEXT("ToolSet_Smooth", "Smooth");
LOCTEXT("ToolSet_Flatten", "Flatten");
LOCTEXT("ToolSet_Ramp", "Ramp");
LOCTEXT("ToolSet_Erosion", "Erosion");
LOCTEXT("ToolSet_HydraErosion", "HydroErosion");
LOCTEXT("ToolSet_Noise", "Noise");
LOCTEXT("ToolSet_Retopologize", "Retopologize");
LOCTEXT("ToolSet_Visibility", "Visibility");
LOCTEXT("ToolSet_BlueprintBrush", "Blueprint Brushes");
LOCTEXT("ToolSet_Select", "Selection");
LOCTEXT("ToolSet_AddComponent", "Add");
LOCTEXT("ToolSet_DeleteComponent", "Delete");
LOCTEXT("ToolSet_MoveToLevel", "Move to Level");
LOCTEXT("ToolSet_Mask", "Selection");
LOCTEXT("ToolSet_CopyPaste", "Copy/Paste");
LOCTEXT("ToolSet_Mirror", "Mirror");
LOCTEXT("ToolSet_Splines", "Edit Splines");
LOCTEXT("BrushSet_Circle", "Circle");
LOCTEXT("BrushSet_Alpha", "Alpha");
LOCTEXT("BrushSet_Pattern", "Pattern");
LOCTEXT("BrushSet_Component", "Component");
LOCTEXT("BrushSet_Gizmo", "Gizmo");
LOCTEXT("BrushSet_Dummy", "NoBrush");
LOCTEXT("BrushSet_Splines", "Splines");
LOCTEXT("Circle_Smooth", "Smooth");
LOCTEXT("Circle_Linear", "Linear");
LOCTEXT("Circle_Spherical", "Spherical");
LOCTEXT("Circle_Tip", "Tip");
LOCTEXT("Circle_Dummy", "NoBrush");
}
FText Result;
ensure(FText::FindText(TEXT("LandscapeEditor"), Name, Result));
return Result;
}
EVisibility FLandscapeEditorDetails::GetTargetLandscapeSelectorVisibility()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->GetLandscapeList().Num() > 1)
{
return EVisibility::Visible;
}
return EVisibility::Collapsed;
}
FText FLandscapeEditorDetails::GetTargetLandscapeName()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode)
{
ULandscapeInfo* Info = LandscapeEdMode->CurrentToolTarget.LandscapeInfo.Get();
if (Info)
{
ALandscapeProxy* Proxy = Info->GetLandscapeProxy();
if (Proxy)
{
return FText::FromString(Proxy->GetActorLabel());
}
}
}
return FText();
}
TSharedRef<SWidget> FLandscapeEditorDetails::GetTargetLandscapeMenu()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode)
{
FMenuBuilder MenuBuilder(true, NULL);
const TArray<FLandscapeListInfo>& LandscapeList = LandscapeEdMode->GetLandscapeList();
for (auto It = LandscapeList.CreateConstIterator(); It; It++)
{
FUIAction Action = FUIAction(FExecuteAction::CreateStatic(&FLandscapeEditorDetails::OnChangeTargetLandscape, MakeWeakObjectPtr(It->Info)));
MenuBuilder.AddMenuEntry(FText::FromString(It->Info->GetLandscapeProxy()->GetActorLabel()), FText(), FSlateIcon(), Action);
}
return MenuBuilder.MakeWidget();
}
return SNullWidget::NullWidget;
}
void FLandscapeEditorDetails::OnChangeTargetLandscape(TWeakObjectPtr<ULandscapeInfo> LandscapeInfo)
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode)
{
LandscapeEdMode->SetTargetLandscape(LandscapeInfo);
}
}
FText FLandscapeEditorDetails::GetCurrentToolName() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentTool != NULL)
{
const TCHAR* CurrentToolName = LandscapeEdMode->CurrentTool->GetToolName();
return GetLocalizedName(FString("ToolSet_") + CurrentToolName);
}
return LOCTEXT("Unknown", "Unknown");
}
FSlateIcon FLandscapeEditorDetails::GetCurrentToolIcon() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentTool != NULL)
{
const TCHAR* CurrentToolName = LandscapeEdMode->CurrentTool->GetToolName();
return FLandscapeEditorCommands::Get().NameToCommandMap.FindChecked(*(FString("Tool_") + CurrentToolName))->GetIcon();
}
return FSlateIcon(FAppStyle::GetAppStyleSetName(), "Default");
}
TSharedRef<SWidget> FLandscapeEditorDetails::GetToolSelector()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL)
{
auto NameToCommandMap = FLandscapeEditorCommands::Get().NameToCommandMap;
FToolMenuBuilder MenuBuilder(true, CommandList);
if (LandscapeEdMode->CurrentToolMode->ToolModeName == "ToolMode_Manage")
{
MenuBuilder.BeginSection(NAME_None, LOCTEXT("NewLandscapeToolsTitle", "New Landscape"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_NewLandscape"), NAME_None, LOCTEXT("Tool.NewLandscape", "New Landscape"), LOCTEXT("Tool.NewLandscape.Tooltip", "Create or import a new landscape"));
MenuBuilder.EndSection();
MenuBuilder.BeginSection(NAME_None, LOCTEXT("ComponentToolsTitle", "Component Tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Select"), NAME_None, LOCTEXT("Tool.SelectComponent", "Selection"), LOCTEXT("Tool.SelectComponent.Tooltip", "Select components to use with other tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_AddComponent"), NAME_None, LOCTEXT("Tool.AddComponent", "Add"), LOCTEXT("Tool.AddComponent.Tooltip", "Add components to the landscape"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_DeleteComponent"), NAME_None, LOCTEXT("Tool.DeleteComponent", "Delete"), LOCTEXT("Tool.DeleteComponent.Tooltip", "Delete components from the landscape, leaving a hole"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_MoveToLevel"), NAME_None, LOCTEXT("Tool.MoveToLevel", "Move to Level"), LOCTEXT("Tool.MoveToLevel.Tooltip", "Move landscape components to a landscape proxy in the currently active streaming level, so that they can be streamed in/out independently of the rest of the landscape"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_ResizeLandscape"), NAME_None, LOCTEXT("Tool.ResizeLandscape", "Change Component Size"), LOCTEXT("Tool.ResizeLandscape.Tooltip", "Change the size of the landscape components"));
MenuBuilder.EndSection();
MenuBuilder.BeginSection(NAME_None, LOCTEXT("SplineToolsTitle", "Spline Tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Splines"), NAME_None, LOCTEXT("Tool.Spline", "Edit Splines"), LOCTEXT("Tool.Spline.Tooltip", "Ctrl+click to add control points\nHaving a control point selected when you ctrl+click will connect to the new control point with a segment\nSpline mesh settings can be found on the details panel when you have segments selected"));
MenuBuilder.EndSection();
}
if (LandscapeEdMode->CurrentToolMode->ToolModeName == "ToolMode_Sculpt")
{
MenuBuilder.BeginSection(NAME_None, LOCTEXT("SculptToolsTitle", "Sculpting Tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Sculpt"), NAME_None, LOCTEXT("Tool.Sculpt", "Sculpt"), LOCTEXT("Tool.Sculpt.Tooltip", "Sculpt height data.\nClick to Raise, Shift+Click to lower"));
if (LandscapeEdMode->CanHaveLandscapeLayersContent())
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Erase"), NAME_None, LOCTEXT("Tool.Erase", "Erase"), LOCTEXT("Tool.Erase.Tooltip", "Erase height data."));
}
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Smooth"), NAME_None, LOCTEXT("Tool.Smooth", "Smooth"), LOCTEXT("Tool.Smooth.Tooltip", "Smooths heightmaps or blend layers"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Flatten"), NAME_None, LOCTEXT("Tool.Flatten", "Flatten"), LOCTEXT("Tool.Flatten.Tooltip", "Flattens an area of heightmap or blend layer"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Ramp"), NAME_None, LOCTEXT("Tool.Ramp", "Ramp"), LOCTEXT("Tool.Ramp.Tooltip", "Creates a ramp between two points"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Erosion"), NAME_None, LOCTEXT("Tool.Erosion", "Erosion"), LOCTEXT("Tool.Erosion.Tooltip", "Thermal Erosion - Simulates erosion caused by the movement of soil from higher areas to lower areas"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_HydraErosion"), NAME_None, LOCTEXT("Tool.HydroErosion", "Hydro Erosion"), LOCTEXT("Tool.HydroErosion.Tooltip", "Hydro Erosion - Simulates erosion caused by rainfall"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Noise"), NAME_None, LOCTEXT("Tool.Noise", "Noise"), LOCTEXT("Tool.Noise.Tooltip", "Adds noise to the heightmap or blend layer"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Retopologize"), NAME_None, LOCTEXT("Tool.Retopologize", "Retopologize"), LOCTEXT("Tool.Retopologize.Tooltip", "Automatically adjusts landscape vertices with an X/Y offset map to improve vertex density on cliffs, reducing texture stretching.\nNote: An X/Y offset map makes the landscape slower to render and paint on with other tools, so only use if needed"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Visibility"), NAME_None, LOCTEXT("Tool.Visibility", "Visibility"), LOCTEXT("Tool.Visibility.Tooltip", "Mask out individual quads in the landscape, leaving a hole."));
if (LandscapeEdMode->CanHaveLandscapeLayersContent())
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_BlueprintBrush"), NAME_None, LOCTEXT("Tool.SculptBlueprintBrush", "Blueprint Brushes"), LOCTEXT("Tool.SculptBlueprintBrush.Tooltip", "Custom sculpting tools created using Blueprint."));
}
MenuBuilder.EndSection();
MenuBuilder.BeginSection(NAME_None, LOCTEXT("RegionToolsTitle", "Region Tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Mask"), NAME_None, LOCTEXT("Tool.RegionSelect", "Selection"), LOCTEXT("Tool.RegionSelect.Tooltip", "Select a region of landscape to use as a mask for other tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_CopyPaste"), NAME_None, LOCTEXT("Tool.RegionCopyPaste", "Copy/Paste"), LOCTEXT("Tool.RegionCopyPaste.Tooltip", "Copy/Paste areas of the landscape, or import/export a copied area of landscape from disk"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Mirror"), NAME_None, LOCTEXT("Tool.Mirror", "Mirror"), LOCTEXT("Tool.Mirror.Tooltip", "Copies one side of a landscape to the other, to easily create a mirrored landscape."));
MenuBuilder.EndSection();
}
if (LandscapeEdMode->CurrentToolMode->ToolModeName == "ToolMode_Paint")
{
MenuBuilder.BeginSection(NAME_None, LOCTEXT("PaintToolsTitle", "Paint Tools"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Paint"), NAME_None, LOCTEXT("Tool.Paint", "Paint"), LOCTEXT("Tool.Paint.Tooltip", "Paints weight data.\nClick to paint, Shift+Click to erase"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Smooth"), NAME_None, LOCTEXT("Tool.Smooth", "Smooth"), LOCTEXT("Tool.Smooth.Tooltip", "Smooths heightmaps or blend layers"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Flatten"), NAME_None, LOCTEXT("Tool.Flatten", "Flatten"), LOCTEXT("Tool.Flatten.Tooltip", "Flattens an area of heightmap or blend layer"));
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_Noise"), NAME_None, LOCTEXT("Tool.Noise", "Noise"), LOCTEXT("Tool.Noise.Tooltip", "Adds noise to the heightmap or blend layer"));
if (LandscapeEdMode->CanHaveLandscapeLayersContent())
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("Tool_BlueprintBrush"), NAME_None, LOCTEXT("Tool.PaintBlueprintBrush", "Blueprint Brushes"), LOCTEXT("Tool.PaintBlueprintBrush.Tooltip", "Custom painting tools created using Blueprint."));
}
MenuBuilder.EndSection();
}
return MenuBuilder.MakeWidget();
}
return SNullWidget::NullWidget;
}
bool FLandscapeEditorDetails::GetToolSelectorIsVisible() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentTool)
{
if (!LandscapeEdMode->CanEditCurrentTarget())
{
return false;
}
if (!IsToolActive("NewLandscape") || LandscapeEdMode->GetLandscapeList().Num() > 0)
{
return true;
}
}
return false;
}
EVisibility FLandscapeEditorDetails::GetToolSelectorVisibility() const
{
if (GetToolSelectorIsVisible())
{
return EVisibility::Visible;
}
return EVisibility::Collapsed;
}
FName FLandscapeEditorDetails::GetCurrentBrushFName() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL)
{
return LandscapeEdMode->LandscapeBrushSets[LandscapeEdMode->CurrentBrushSetIndex].BrushSetName;
}
return NAME_None;
}
FText FLandscapeEditorDetails::GetCurrentBrushName() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL)
{
const FName CurrentBrushSetName = LandscapeEdMode->LandscapeBrushSets[LandscapeEdMode->CurrentBrushSetIndex].BrushSetName;
return GetLocalizedName(CurrentBrushSetName.ToString());
}
return LOCTEXT("Unknown", "Unknown");
}
FSlateIcon FLandscapeEditorDetails::GetCurrentBrushIcon() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL)
{
const FName CurrentBrushSetName = LandscapeEdMode->LandscapeBrushSets[LandscapeEdMode->CurrentBrushSetIndex].BrushSetName;
TSharedPtr<FUICommandInfo> Command = FLandscapeEditorCommands::Get().NameToCommandMap.FindRef(CurrentBrushSetName);
if (Command.IsValid())
{
return Command->GetIcon();
}
}
return FSlateIcon(FAppStyle::GetAppStyleSetName(), "Default");
}
TSharedRef<SWidget> FLandscapeEditorDetails::GetBrushSelector()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentTool)
{
auto NameToCommandMap = FLandscapeEditorCommands::Get().NameToCommandMap;
FToolMenuBuilder MenuBuilder(true, CommandList);
MenuBuilder.BeginSection(NAME_None, LOCTEXT("BrushesTitle", "Brushes"));
if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Circle"))
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Circle"), NAME_None, LOCTEXT("Brush.Circle", "Circle"), LOCTEXT("Brush.Circle.Brushtip", "Simple circular brush"));
}
if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Alpha"))
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Alpha"), NAME_None, LOCTEXT("Brush.Alpha.Alpha", "Alpha"), LOCTEXT("Brush.Alpha.Alpha.Tooltip", "Alpha brush, orients a mask image with the brush stroke"));
}
if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Pattern"))
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Pattern"), NAME_None, LOCTEXT("Brush.Alpha.Pattern", "Pattern"), LOCTEXT("Brush.Alpha.Pattern.Tooltip", "Pattern brush, tiles a mask image across the landscape"));
}
if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Component"))
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Component"), NAME_None, LOCTEXT("Brush.Component", "Component"), LOCTEXT("Brush.Component.Brushtip", "Work with entire landscape components"));
}
if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Gizmo"))
{
MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Gizmo"), NAME_None, LOCTEXT("Brush.Gizmo", "Gizmo"), LOCTEXT("Brush.Gizmo.Brushtip", "Work with the landscape gizmo, used for copy/pasting landscape"));
}
//if (LandscapeEdMode->CurrentTool->ValidBrushes.Contains("BrushSet_Splines"))
//{
// MenuBuilder.AddToolButton(NameToCommandMap.FindChecked("BrushSet_Splines"), NAME_None, LOCTEXT("Brush.Splines", "Splines"), LOCTEXT("Brush.Splines.Brushtip", "Edit Splines"));
//}
MenuBuilder.EndSection();
return MenuBuilder.MakeWidget();
}
return SNullWidget::NullWidget;
}
bool FLandscapeEditorDetails::GetBrushSelectorIsVisible() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentTool)
{
if (LandscapeEdMode->CurrentTool->ValidBrushes.Num() >= 2)
{
return true;
}
}
return false;
}
EVisibility FLandscapeEditorDetails::GetBrushSelectorVisibility() const
{
return GetBrushSelectorIsVisible() ? EVisibility::Visible : EVisibility::Collapsed;
}
FName FLandscapeEditorDetails::GetCurrentBrushFalloffFName() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL && GetBrushFalloffSelectorIsVisible())
{
return LandscapeEdMode->CurrentBrush->GetBrushName();
}
return NAME_None;
}
FText FLandscapeEditorDetails::GetCurrentBrushFalloffName() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL && GetBrushFalloffSelectorIsVisible())
{
const TCHAR* CurrentBrushName = LandscapeEdMode->CurrentBrush->GetBrushName();
return GetLocalizedName(CurrentBrushName);
}
return LOCTEXT("Unknown", "Unknown");
}
FSlateIcon FLandscapeEditorDetails::GetCurrentBrushFalloffIcon() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentBrush != NULL)
{
const FName CurrentBrushName = LandscapeEdMode->CurrentBrush->GetBrushName();
TSharedPtr<FUICommandInfo> Command = FLandscapeEditorCommands::Get().NameToCommandMap.FindRef(CurrentBrushName);
if (Command.IsValid())
{
return Command->GetIcon();
}
}
return FSlateIcon(FAppStyle::GetAppStyleSetName(), "Default");
}
void FLandscapeEditorDetails::SetBrushCommand(FName InBrush)
{
TSharedPtr<FUICommandInfo> BrushCommand = FLandscapeEditorCommands::Get().NameToCommandMap.FindRef(InBrush);
if (CommandList.IsValid() && BrushCommand.IsValid())
{
CommandList->ExecuteAction( BrushCommand.ToSharedRef() );
}
}
TSharedRef<SWidget> FLandscapeEditorDetails::GetBrushFalloffSelector()
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentTool)
{
auto NameToCommandMap = FLandscapeEditorCommands::Get().NameToCommandMap;
FToolMenuBuilder MenuBuilder(true, CommandList);
MenuBuilder.BeginSection(NAME_None, LOCTEXT("FalloffTitle", "Falloff"));
MenuBuilder.AddToolButton(FLandscapeEditorCommands::Get().CircleBrush_Smooth, NAME_None, LOCTEXT("Brush.Circle.Smooth", "Smooth"), LOCTEXT("Brush.Circle.Smooth.Tooltip", "Smooth falloff"));
MenuBuilder.AddToolButton(FLandscapeEditorCommands::Get().CircleBrush_Linear, NAME_None, LOCTEXT("Brush.Circle.Linear", "Linear"), LOCTEXT("Brush.Circle.Linear.Tooltip", "Sharp, linear falloff"));
MenuBuilder.AddToolButton(FLandscapeEditorCommands::Get().CircleBrush_Spherical, NAME_None, LOCTEXT("Brush.Circle.Spherical", "Spherical"), LOCTEXT("Brush.Circle.Spherical.Tooltip", "Spherical falloff, smooth at the center and sharp at the edge"));
MenuBuilder.AddToolButton(FLandscapeEditorCommands::Get().CircleBrush_Tip, NAME_None, LOCTEXT("Brush.Circle.Tip", "Tip"), LOCTEXT("Brush.Circle.Tip.Tooltip", "Tip falloff, sharp at the center and smooth at the edge"));
MenuBuilder.EndSection();
return MenuBuilder.MakeWidget();
}
return SNullWidget::NullWidget;
}
bool FLandscapeEditorDetails::GetBrushFalloffSelectorIsVisible() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
if (LandscapeEdMode && LandscapeEdMode->CurrentBrush != NULL)
{
const FLandscapeBrushSet& CurrentBrushSet = LandscapeEdMode->LandscapeBrushSets[LandscapeEdMode->CurrentBrushSetIndex];
if (CurrentBrushSet.Brushes.Num() >= 2)
{
return true;
}
}
return false;
}
EVisibility FLandscapeEditorDetails::GetBrushFalloffSelectorVisibility() const
{
return GetBrushFalloffSelectorIsVisible() ? EVisibility::Visible : EVisibility::Collapsed;
}
bool FLandscapeEditorDetails::IsBrushSetEnabled() const
{
FEdModeLandscape* LandscapeEdMode = GetEditorMode();
return (LandscapeEdMode != nullptr && LandscapeEdMode->GetLandscapeList().Num() > 0);
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink