CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Editor/Persona/Private/SAnimationBlendSpaceGridWidget.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

2972 lines
106 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SAnimationBlendSpaceGridWidget.h"
#include "Animation/AnimSequence.h"
#include "Animation/BlendSpace.h"
#include "Animation/BlendSpace1D.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/Text/STextBlock.h"
#include "Rendering/DrawElements.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/MenuStack.h"
#include "Framework/Application/SlateApplication.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/SNumericEntryBox.h"
#include "Widgets/SToolTip.h"
#include "IDetailsView.h"
#include "UObject/StructOnScope.h"
#include "Styling/AppStyle.h"
#include "PropertyEditorModule.h"
#include "IStructureDetailsView.h"
#include "Customization/BlendSampleDetails.h"
#include "AssetRegistry/AssetData.h"
#include "DragAndDrop/AssetDragDropOp.h"
#include "Settings/EditorStyleSettings.h"
#include "Widgets/Input/SButton.h"
#include "Fonts/FontMeasure.h"
#include "Modules/ModuleManager.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Styling/StyleColors.h"
#include "JsonObjectConverter.h"
#include "HAL/PlatformApplicationMisc.h"
#include "AnimGraphNode_BlendSpaceGraphBase.h"
#include "BlendSpaceGraph.h"
#include "AnimationBlendSpaceSampleGraph.h"
#include "EdGraphUtilities.h"
#include "AnimGraphNode_BlendSpaceSampleResult.h"
#include "ScopedTransaction.h"
#include "Framework/Commands/GenericCommands.h"
#include "Framework/Commands/UICommandList.h"
//UE_DISABLE_OPTIMIZATION
#define LOCTEXT_NAMESPACE "SAnimationBlendSpaceGridWidget"
// Draws additional data on the triangulation to help debugging
//#define DEBUG_BLENDSPACE_TRIANGULATION
// Threshold for it being considered a problem that when a lookup is made at the same location as a
// sample, the returned weight is less than this.
static const float SampleLookupWeightThreshold = 0.2f;
// Flag any triangle that has an interior angle smaller than this (degrees), calculated from the
// normalized positions
static const float CriticalTriangulationAngle = 1.0f;
// Flag any triangle that has a smaller area than this (normalized units)
static const float CriticalTriangulationArea = 5e-4f;
// Identifies the clipboard contents as being a blend sample
static const FString BlendSampleClipboardHeaderAsset = TEXT("COPY_BLENDSAMPLE_ASSET");
static const FString BlendSampleClipboardHeaderGraph = TEXT("COPY_BLENDSAMPLE_GRAPH");
//======================================================================================================================
// Paint a filled triangle
static void PaintTriangle(
const FVector2D& P0,
const FVector2D& P1,
const FVector2D& P2,
const FGeometry& AllottedGeometry,
FLinearColor Color,
const FSlateBrush* Brush,
FSlateWindowElementList& OutDrawElements,
int32 DrawLayerId)
{
const FVector2D* Points[3] = { &P0, &P1, &P2 };
TArray<FSlateVertex> Vertices;
Vertices.Reserve(3);
for (int32 PointIndex = 0; PointIndex != 3; ++PointIndex)
{
Vertices.AddZeroed();
FSlateVertex& NewVert = Vertices.Last();
NewVert.Position = FVector2f(AllottedGeometry.LocalToAbsolute(*Points[PointIndex])); // LWC_TODO: Precision loss
NewVert.Color = Color.ToFColor(false);
}
// Fill by making triangles
TArray<SlateIndex> VertexIndices = { 0, 1, 2 };
FSlateDrawElement::MakeCustomVerts(
OutDrawElements, DrawLayerId, Brush->GetRenderingResource(), Vertices, VertexIndices, nullptr, 0, 0);
}
//======================================================================================================================
// Paints a filled polygon with outline, defined by a set of points which don't need to be sorted.
// This will handle concave polygons, but only if the centroid lies inside the polygon.
static void PaintPolygon(
TArray<FVector2D>& Points,
const FGeometry& AllottedGeometry,
FLinearColor FillColor,
FLinearColor OutlineColor,
const FSlateBrush* Brush,
FSlateWindowElementList& OutDrawElements,
int32 DrawLayerId)
{
TArray<FSlateVertex> Vertices;
Vertices.Reserve(Points.Num() + 1);
// Add a mid-position vertex so that we handle polygons that aren't completely convex
Vertices.AddZeroed();
FSlateVertex& MidVertex = Vertices.Last();
for (int32 PointIndex = 0; PointIndex != Points.Num(); ++PointIndex)
{
Vertices.AddZeroed();
FSlateVertex& NewVert = Vertices.Last();
NewVert.Position = FVector2f(AllottedGeometry.LocalToAbsolute(Points[PointIndex])); // LWC_TODO: Precision loss
NewVert.Color = FillColor.ToFColor(false);
MidVertex.Position += NewVert.Position;
}
MidVertex.Position /= static_cast<float>(Points.Num());
MidVertex.Color = FillColor.ToFColor(false);
// Make sure the points all wind correctly relative to the mid point
struct FComparePoints
{
FComparePoints(const FSlateVertex& Mid) : MidPoint(Mid) {}
bool operator()(const FSlateVertex& A, const FSlateVertex& B) const
{
const FVector2D DeltaA = FVector2D(A.Position) - FVector2D(MidPoint.Position);
const FVector2D DeltaB = FVector2D(B.Position) - FVector2D(MidPoint.Position);
const double AngleA = FMath::Atan2(DeltaA.Y, DeltaA.X);
const double AngleB = FMath::Atan2(DeltaB.Y, DeltaB.X);
return AngleA < AngleB;
}
FSlateVertex MidPoint;
};
Algo::Sort(MakeArrayView(Vertices.GetData() + 1, Vertices.Num() - 1), FComparePoints(MidVertex));
if (FillColor.A > 0)
{
// Fill by making triangles
TArray<SlateIndex> VertexIndices;
for (int VertexIndex = 1; VertexIndex < Vertices.Num(); ++VertexIndex)
{
VertexIndices.Add(0);
VertexIndices.Add(VertexIndex);
VertexIndices.Add(VertexIndex + 1 >= Vertices.Num() ? 1 : VertexIndex + 1);
}
FSlateDrawElement::MakeCustomVerts(
OutDrawElements, DrawLayerId, Brush->GetRenderingResource(), Vertices, VertexIndices, nullptr, 0, 0);
}
if (OutlineColor.A > 0)
{
TArray<FVector2D> LinePoints;
LinePoints.Reserve(Points.Num() + 1);
for (int VertexIndex = 1; VertexIndex <= Vertices.Num(); ++VertexIndex)
{
LinePoints.Add(FVector2D(VertexIndex < Vertices.Num() ? Vertices[VertexIndex].Position : Vertices[1].Position));
}
FSlateDrawElement::MakeLines(
OutDrawElements, DrawLayerId + 1, FPaintGeometry(), LinePoints, ESlateDrawEffect::None, OutlineColor, true, 1.0f);
}
}
//======================================================================================================================
static void PaintCircle(
const FVector2D& Centre,
const float Radius,
const int32 NumVerts,
const FGeometry& AllottedGeometry,
FLinearColor FillColor,
FLinearColor OutlineColor,
const FSlateBrush* Brush,
FSlateWindowElementList& OutDrawElements,
int32 DrawLayerId)
{
// NumVerts needs to be a multiple of 4
int32 NumVertsPerSector = ((NumVerts + 3) / 4);
TArray<FVector2D> Points;
Points.SetNum(NumVertsPerSector * 4);
for (int32 Index = 0 ; Index != NumVertsPerSector ; ++Index)
{
float Angle = Index * (HALF_PI / NumVertsPerSector);
float S, C;
FMath::SinCos(&S, &C, Angle);
Points[Index + NumVertsPerSector * 0] = Centre + FVector2D(C * Radius, S * Radius);
Points[Index + NumVertsPerSector * 1] = Centre + FVector2D(-S * Radius, C * Radius);
Points[Index + NumVertsPerSector * 2] = Centre + FVector2D(-C * Radius, -S * Radius);
Points[Index + NumVertsPerSector * 3] = Centre + FVector2D(S * Radius, -C * Radius);
}
PaintPolygon(Points, AllottedGeometry, FillColor, OutlineColor, Brush, OutDrawElements, DrawLayerId);
}
void SBlendSpaceGridWidget::Construct(const FArguments& InArgs)
{
BlendSpaceBase = InArgs._BlendSpaceBase;
PreviousBlendSpaceBase = BlendSpaceBase.Get();
TargetPosition = InArgs._Position;
FilteredPosition = InArgs._FilteredPosition;
NotifyHook = InArgs._NotifyHook;
OnSampleAdded = InArgs._OnSampleAdded;
OnSampleDuplicated = InArgs._OnSampleDuplicated;
OnSampleMoved = InArgs._OnSampleMoved;
OnSampleRemoved = InArgs._OnSampleRemoved;
OnSampleReplaced = InArgs._OnSampleReplaced;
OnNavigateUp = InArgs._OnNavigateUp;
OnNavigateDown = InArgs._OnNavigateDown;
OnCanvasDoubleClicked = InArgs._OnCanvasDoubleClicked;
OnSampleDoubleClicked = InArgs._OnSampleDoubleClicked;
OnGetBlendSpaceSampleName = InArgs._OnGetBlendSpaceSampleName;
OnExtendSampleTooltip = InArgs._OnExtendSampleTooltip;
bReadOnly = InArgs._ReadOnly;
bShowAxisLabels = InArgs._ShowAxisLabels;
bShowSettingsButtons = InArgs._ShowSettingsButtons;
StatusBarName = InArgs._StatusBarName;
GridType = (BlendSpaceBase.Get() != nullptr && BlendSpaceBase.Get()->IsA<UBlendSpace1D>()) ? EGridType::SingleAxis : EGridType::TwoAxis;
BlendParametersToDraw = (GridType == EGridType::SingleAxis) ? 1 : 2;
HighlightedSampleIndex = SelectedSampleIndex = DraggedSampleIndex = ToolTipSampleIndex = INDEX_NONE;
DragState = EDragState::None;
// Initialize flags
bHighlightPreviewPin = false;
// Initialize preview value to center or the grid
PreviewPosition.X = BlendSpaceBase.Get() != nullptr ? (BlendSpaceBase.Get()->GetBlendParameter(0).GetRange() * .5f) + BlendSpaceBase.Get()->GetBlendParameter(0).Min : 0.0f;
PreviewPosition.Y = BlendSpaceBase.Get() != nullptr ? (GridType == EGridType::TwoAxis ? (BlendSpaceBase.Get()->GetBlendParameter(1).GetRange() * .5f) + BlendSpaceBase.Get()->GetBlendParameter(1).Min : 0.0f) : 0.0f;
PreviewPosition.Z = 0.0f;
PreviewFilteredPosition = PreviewPosition;
bShowTriangulation = true;
bMouseIsOverGeometry = false;
bRefreshCachedData = true;
bStretchToFit = true;
bShowAnimationNames = false;
// Register and bind all our menu commands
FGenericCommands::Register();
BindCommands();
InvalidSamplePositionDragDropText = FText::FromString(TEXT("Invalid Sample Position"));
// Retrieve UI color values
KeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Regular");
HighlightKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Highlight");
SelectKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Pressed");
PreDragKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Pressed");
DragKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Drag");
InvalidColor = FAppStyle::GetSlateColor("BlendSpaceKey.Invalid");
DropKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Drop");
PreviewKeyColor = FAppStyle::GetSlateColor("BlendSpaceKey.Preview");
GridLinesColor = GetDefault<UEditorStyleSettings>()->RegularColor;
GridOutlineColor = GetDefault<UEditorStyleSettings>()->RuleColor;
TriangulationColor = FSlateColor(EStyleColor::Foreground);
TriangulationCurrentColor = FSlateColor(EStyleColor::Highlight);
// Retrieve background and sample key brushes
BackgroundImage = FAppStyle::GetBrush(TEXT("Graph.Panel.SolidBackground"));
KeyBrush = FAppStyle::GetBrush("CurveEd.CurveKey");
PreviewBrush = FAppStyle::GetBrush("BlendSpaceEditor.PreviewIcon");
ArrowBrushes[(uint8)EArrowDirection::Up] = FAppStyle::GetBrush("BlendSpaceEditor.ArrowUp");
ArrowBrushes[(uint8)EArrowDirection::Down] = FAppStyle::GetBrush("BlendSpaceEditor.ArrowDown");
ArrowBrushes[(uint8)EArrowDirection::Right] = FAppStyle::GetBrush("BlendSpaceEditor.ArrowRight");
ArrowBrushes[(uint8)EArrowDirection::Left] = FAppStyle::GetBrush("BlendSpaceEditor.ArrowLeft");
LabelBrush = FAppStyle::GetBrush(TEXT("BlendSpaceEditor.LabelBackground"));
// Retrieve font data
FontInfo = FAppStyle::GetFontStyle("CurveEd.InfoFont");
// Initialize UI layout values
KeySize = FVector2D(11.0f, 11.0f);
PreviewSize = FVector2D(21.0f, 21.0f);
DragThreshold = 9.0f;
ClickAndHighlightThreshold = 12.0f;
TextMargin = 8.0f;
GridMargin = bShowAxisLabels ? FMargin(MaxVerticalAxisTextWidth + (TextMargin * 2.0f), TextMargin, (HorizontalAxisMaxTextWidth *.5f) + TextMargin, MaxHorizontalAxisTextHeight + (TextMargin * 2.0f)) :
FMargin(TextMargin, TextMargin, TextMargin, TextMargin);
const bool bShowInputBoxLabel = true;
// Widget construction
this->ChildSlot
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SBorder)
.VAlign(VAlign_Top)
.HAlign(HAlign_Left)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.DesiredSizeScale(FVector2D(1.0f, 1.0f))
.Padding_Lambda([&]() { return FMargin(GridMargin.Left + 6.f, 0, 0, 0) + GridRatioMargin; })
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot() // Button to show triangulation
.AutoWidth()
[
SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetTriangulationButtonVisibility)))
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("ShowTriangulation", "Show Triangulation"))
.OnClicked(this, &SBlendSpaceGridWidget::ToggleTriangulationVisibility)
.ButtonColorAndOpacity_Lambda([this]() -> FLinearColor { return bShowTriangulation ? FAppStyle::GetSlateColor("SelectionColor").GetSpecifiedColor() : FLinearColor::White; })
.ContentPadding(1.f)
[
SNew(SImage)
.Image(FAppStyle::GetBrush("BlendSpaceEditor.ToggleTriangulation"))
.ColorAndOpacity(FSlateColor::UseForeground())
]
]
]
+ SHorizontalBox::Slot() // Button to toggle labels
.AutoWidth()
[
SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetAnimationNamesButtonVisibility)))
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("ShowAnimationNames", "Show Sample Names"))
.OnClicked(this, &SBlendSpaceGridWidget::ToggleShowAnimationNames)
.ButtonColorAndOpacity_Lambda([this]() -> FLinearColor { return bShowAnimationNames ? FAppStyle::GetSlateColor("SelectionColor").GetSpecifiedColor() : FLinearColor::White; })
.ContentPadding(1.f)
[
SNew(SImage)
.Image(FAppStyle::GetBrush("BlendSpaceEditor.ToggleLabels"))
.ColorAndOpacity(FSlateColor::UseForeground())
]
]
]
+ SHorizontalBox::Slot() // Button to fit or stretch the graph
.AutoWidth()
[
SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetFittingButtonVisibility)))
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(this, &SBlendSpaceGridWidget::GetFittingTypeButtonToolTipText)
.OnClicked(this, &SBlendSpaceGridWidget::ToggleFittingType)
.ContentPadding(1.f)
.ButtonColorAndOpacity_Lambda([this]() -> FLinearColor { return bStretchToFit ? FAppStyle::GetSlateColor("SelectionColor").GetSpecifiedColor() : FLinearColor::White; })
[
SNew(SImage)
.Image(FAppStyle::GetBrush("BlendSpaceEditor.ZoomToFit"))
.ColorAndOpacity(FSlateColor::UseForeground())
]
]
]
+ SHorizontalBox::Slot() // Sample X value input
.AutoWidth()
[
SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetInputBoxVisibility, 0)))
.VAlign(VAlign_Center)
[
CreateGridEntryBox(0, bShowInputBoxLabel).ToSharedRef()
]
]
+ SHorizontalBox::Slot() // Sample Y value input
.AutoWidth()
[
SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("NoBorder"))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetInputBoxVisibility, 1)))
.VAlign(VAlign_Center)
[
CreateGridEntryBox(1, bShowInputBoxLabel).ToSharedRef()
]
]
]
+ SVerticalBox::Slot() // Tip for dragging in, when there are no samples
.AutoHeight()
.Padding(FMargin(2.0f, 3.0f, 0.0f, 0.0f ))
[
SNew(STextBlock)
.Text(LOCTEXT("BlendSpaceSamplesToolTip", "Drag and Drop Animations from the Asset Browser to place Sample Points"))
.Font(FAppStyle::GetFontStyle(TEXT("AnimViewport.MessageFont")))
.ColorAndOpacity(FLinearColor(1.0f, 1.0f, 1.0f, 0.7f))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetSampleToolTipVisibility)))
]
+ SVerticalBox::Slot() // Tip for adjusting the preview point
.AutoHeight()
.Padding(FMargin(2.0f, 3.0f, 0.0f, 0.0f))
[
SNew(STextBlock)
.Text(LOCTEXT("BlendspacePreviewToolTip", "Hold Control to set the Preview Point (Green)" ))
.Font(FAppStyle::GetFontStyle(TEXT("AnimViewport.MessageFont")))
.ColorAndOpacity(FLinearColor(1.0f, 1.0f, 1.0f, 0.7f))
.Visibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &SBlendSpaceGridWidget::GetPreviewToolTipVisibility)))
]
]
]
]
]
];
SAssignNew(ToolTip, SToolTip)
.BorderImage(FCoreStyle::Get().GetBrush("ToolTip.Background"))
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(STextBlock)
.Text(this, &SBlendSpaceGridWidget::GetToolTipAnimationName)
.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
]
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(STextBlock)
.Text(this, &SBlendSpaceGridWidget::GetToolTipSampleValue)
.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
]
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(STextBlock)
.Text(this, &SBlendSpaceGridWidget::GetToolTipSampleValidity)
.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
.Visibility_Lambda([this]() { return GetToolTipSampleValidity().IsEmpty() ? EVisibility::Collapsed : EVisibility::Visible; })
]
+ SVerticalBox::Slot()
.AutoHeight()
[
SAssignNew(ToolTipExtensionContainer, SBox)
]
];
if(TargetPosition.IsSet())
{
StartPreviewing();
}
}
SBlendSpaceGridWidget::~SBlendSpaceGridWidget()
{
EnableStatusBarMessage(false);
}
TSharedPtr<SWidget> SBlendSpaceGridWidget::CreateGridEntryBox(const int32 BoxIndex, const bool bShowLabel)
{
return SNew(SNumericEntryBox<float>)
.Font(FAppStyle::GetFontStyle("CurveEd.InfoFont"))
.Value(this, &SBlendSpaceGridWidget::GetInputBoxValue, BoxIndex)
.UndeterminedString(LOCTEXT("MultipleValues", "Multiple Values"))
.OnValueCommitted(this, &SBlendSpaceGridWidget::OnInputBoxValueCommited, BoxIndex)
.OnValueChanged(this, &SBlendSpaceGridWidget::OnInputBoxValueChanged, BoxIndex, true)
.OnBeginSliderMovement(this, &SBlendSpaceGridWidget::OnInputSliderBegin, BoxIndex)
.OnEndSliderMovement(this, &SBlendSpaceGridWidget::OnInputSliderEnd, BoxIndex)
.LabelVAlign(VAlign_Center)
.AllowSpin(true)
.MinValue(this, &SBlendSpaceGridWidget::GetInputBoxMinValue, BoxIndex)
.MaxValue(this, &SBlendSpaceGridWidget::GetInputBoxMaxValue, BoxIndex)
.MinSliderValue(this, &SBlendSpaceGridWidget::GetInputBoxMinValue, BoxIndex)
.MaxSliderValue(this, &SBlendSpaceGridWidget::GetInputBoxMaxValue, BoxIndex)
.MinDesiredValueWidth(60.0f)
.Label()
[
SNew(STextBlock)
.Visibility(bShowLabel ? EVisibility::Visible : EVisibility::Collapsed)
.Text_Lambda([this, BoxIndex]() { return (BoxIndex == 0) ? ParameterXName : ParameterYName; })
];
}
int32 SBlendSpaceGridWidget::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
SCompoundWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled && IsEnabled());
PaintBackgroundAndGrid(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
#if 0
// Showing the sample-weights on the grid points is not useful to end users, but can be helpful when debugging
// the grid-based interpolation.
PaintGridSampleWeights(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
#endif
PaintTriangulation(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
PaintSampleKeys(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
if(bShowAxisLabels)
{
PaintAxisText(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
}
if (bShowAnimationNames)
{
PaintAnimationNames(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId);
}
return LayerId;
}
void SBlendSpaceGridWidget::PaintBackgroundAndGrid(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32& DrawLayerId) const
{
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
// Create the grid
const FVector2D GridSize = CachedGridRectangle.GetSize();
const FVector2D GridOffset = CachedGridRectangle.GetTopLeft();
// Fill the background of the grid
FSlateDrawElement::MakeBox( OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(GridSize, FSlateLayoutTransform(GridOffset)), BackgroundImage );
TArray<FVector2D> LinePoints;
// Draw grid lines
LinePoints.SetNumZeroed(2);
const FVector2D StartVectors[2] = { FVector2D(1.0f, 0.0f), FVector2D(0.0f, 1.0f) };
const FVector2D OffsetVectors[2] = { FVector2D(0.0f, GridSize.Y), FVector2D(GridSize.X, 0.0f) };
for (uint32 ParameterIndex = 0; ParameterIndex < BlendParametersToDraw; ++ParameterIndex)
{
const FBlendParameter& BlendParameter = BlendSpace->GetBlendParameter(ParameterIndex);
const float Steps = static_cast<float>(GridSize[ParameterIndex] / ( BlendParameter.GridNum));
for (int32 Index = 1; Index < BlendParameter.GridNum; ++Index)
{
// Calculate line points
LinePoints[0] = ((Index * Steps) * StartVectors[ParameterIndex]) + GridOffset;
LinePoints[1] = LinePoints[0] + OffsetVectors[ParameterIndex];
FSlateDrawElement::MakeLines( OutDrawElements, DrawLayerId + 2, AllottedGeometry.ToPaintGeometry(), LinePoints, ESlateDrawEffect::None, GridLinesColor, true);
}
}
// Draw outer grid lines separately (this will avoid missing lines with 1D blend spaces)
LinePoints.SetNumZeroed(5);
// Top line
LinePoints[0] = GridOffset;
LinePoints[1] = GridOffset;
LinePoints[1].X += GridSize.X;
LinePoints[2] = GridOffset;
LinePoints[2].X += GridSize.X;
LinePoints[2].Y += GridSize.Y;
LinePoints[3] = GridOffset;
LinePoints[3].Y += GridSize.Y;
LinePoints[4] = GridOffset;
FSlateDrawElement::MakeLines( OutDrawElements, DrawLayerId + 3, AllottedGeometry.ToPaintGeometry(), LinePoints, ESlateDrawEffect::None, GridOutlineColor, true, 2.0f);
}
DrawLayerId += 3;
}
//======================================================================================================================
float SBlendSpaceGridWidget::GetSampleLookupWeight(int32 SampleIndex) const
{
const UBlendSpace* BlendSpace = BlendSpaceBase.Get();
if (BlendSpace && BlendSpace->bInterpolateUsingGrid)
{
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
const FBlendSample& Sample = Samples[SampleIndex];
TArray<FBlendSampleData> SampleDataList;
int32 TempTriangulationIndex = -1;
BlendSpace->GetSamplesFromBlendInput(Sample.SampleValue, SampleDataList, TempTriangulationIndex, true);
float LookedUpSampleWeight = 0.0f;
for (const FBlendSampleData& LookedUpSample : SampleDataList)
{
if (LookedUpSample.SampleDataIndex == SampleIndex)
{
LookedUpSampleWeight += LookedUpSample.GetClampedWeight();
}
}
return FMath::Clamp(LookedUpSampleWeight, 0.0f, 1.0f);
}
return 1.0f; // Return 1 to avoid anything treating this as a problem
}
//======================================================================================================================
void SBlendSpaceGridWidget::PaintSampleKeys(
const FGeometry& AllottedGeometry,
const FSlateRect& MyCullingRect,
FSlateWindowElementList& OutDrawElements,
int32& DrawLayerId) const
{
const int32 FilteredPositionLayer = DrawLayerId + 1;
const int32 PreviewPositionLayer = DrawLayerId + 2;
const int32 SampleLayer = DrawLayerId + 3;
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
// Draw keys
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
for (int32 SampleIndex = 0; SampleIndex < Samples.Num(); ++SampleIndex)
{
const FBlendSample& Sample = Samples[SampleIndex];
FLinearColor DrawColor = KeyColor.GetSpecifiedColor();
if (DraggedSampleIndex == SampleIndex)
{
DrawColor = (DragState == EDragState::PreDrag) ? PreDragKeyColor.GetSpecifiedColor() : DragKeyColor.GetSpecifiedColor();
}
else if (SelectedSampleIndex == SampleIndex)
{
DrawColor = SelectKeyColor.GetSpecifiedColor();
}
else if (HighlightedSampleIndex == SampleIndex)
{
DrawColor = HighlightKeyColor.GetSpecifiedColor();
}
else if(!Sample.bIsValid)
{
DrawColor = InvalidColor.GetSpecifiedColor();
}
const FVector2D GridPosition = SampleValueToScreenPosition(Sample.SampleValue) - (KeySize * 0.5f);
FSlateDrawElement::MakeBox(
OutDrawElements, SampleLayer, AllottedGeometry.ToPaintGeometry(KeySize, FSlateLayoutTransform(GridPosition)),
KeyBrush, ESlateDrawEffect::None, DrawColor );
const float SampleLookupWeight = GetSampleLookupWeight(SampleIndex);
if (SampleLookupWeight <= SampleLookupWeightThreshold)
{
const FVector2D CirclePosition = SampleValueToScreenPosition(Sample.SampleValue);
FLinearColor IsolatedColor = FLinearColor::Red;
IsolatedColor.A = SampleLookupWeightThreshold > 0.0f ?
(SampleLookupWeightThreshold - SampleLookupWeight) / SampleLookupWeightThreshold :
1.0f;
IsolatedColor.A *= 0.4f;
PaintCircle(CirclePosition, 8.0f, 12, AllottedGeometry, IsolatedColor, IsolatedColor,
LabelBrush, OutDrawElements, SampleLayer - 1);
}
}
// Always draw the filtered position which comes back from whatever is running
{
const FVector2D GridPosition = SampleValueToScreenPosition(PreviewFilteredPosition) - (PreviewSize * .5f);
FSlateDrawElement::MakeBox(
OutDrawElements, FilteredPositionLayer, AllottedGeometry.ToPaintGeometry(PreviewSize, FSlateLayoutTransform(GridPosition)),
PreviewBrush, ESlateDrawEffect::None, PreviewKeyColor.GetSpecifiedColor() * 0.7f);
}
// Always draw the preview position
{
const FVector2D GridPosition = SampleValueToScreenPosition(PreviewPosition) - (PreviewSize * .5f);
FSlateDrawElement::MakeBox(
OutDrawElements, PreviewPositionLayer, AllottedGeometry.ToPaintGeometry(PreviewSize, FSlateLayoutTransform(GridPosition)),
PreviewBrush, ESlateDrawEffect::None, PreviewKeyColor.GetSpecifiedColor());
}
if (DragState == EDragState::DragDrop || DragState == EDragState::InvalidDragDrop)
{
const FVector2D GridPoint = SnapScreenPositionToGrid(
LocalMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown()) - (KeySize * .5f);
FSlateDrawElement::MakeBox(
OutDrawElements, SampleLayer, AllottedGeometry.ToPaintGeometry(KeySize, FSlateLayoutTransform(GridPoint)), KeyBrush, ESlateDrawEffect::None,
(DragState == EDragState::DragDrop) ? DropKeyColor.GetSpecifiedColor() : InvalidColor.GetSpecifiedColor() );
}
// Also show the weights that are getting picked up as bars, using two overlaid boxes
if (bSamplePreviewing && FSlateApplication::Get().GetModifierKeys().IsAltDown())
{
for (const FBlendSampleData& PreviewedSample : PreviewedSamples)
{
float Weight = PreviewedSample.TotalWeight;
int32 SampleIndex = PreviewedSample.SampleDataIndex;
FVector2D Point = SampleValueToScreenPosition(Samples[SampleIndex].SampleValue);
float MaxWeightWidth = 48;
float WeightHeight = 6;
float Border = 1.0f;
Point.Y -= KeySize.Y / 2 + WeightHeight * 1.25;
Point.X -= MaxWeightWidth * 0.5f;
FGeometry FillGeometry = AllottedGeometry.MakeChild(
FVector2D(MaxWeightWidth, WeightHeight),
FSlateLayoutTransform(FVector2D(Point.X, Point.Y))
);
FGeometry BorderGeometry = AllottedGeometry.MakeChild(
FVector2D(Weight * (MaxWeightWidth - 2 * Border), WeightHeight - 2 * Border),
FSlateLayoutTransform(FVector2D(Point.X + Border, Point.Y + Border))
);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, FillGeometry.ToPaintGeometry(),
LabelBrush, ESlateDrawEffect::None, FLinearColor::Black);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 2, BorderGeometry.ToPaintGeometry(),
LabelBrush, ESlateDrawEffect::None, FLinearColor::Gray);
}
}
}
DrawLayerId += 3;
}
//======================================================================================================================
void SBlendSpaceGridWidget::PaintAxisText(
const FGeometry& AllottedGeometry,
const FSlateRect& MyCullingRect,
FSlateWindowElementList& OutDrawElements,
int32& DrawLayerId) const
{
const TSharedRef< FSlateFontMeasure > FontMeasure = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
const FVector2D GridCenter = CachedGridRectangle.GetCenter();
// X axis
FString Text = ParameterXName.ToString();
FVector2D TextSize = FontMeasure->Measure(Text, FontInfo);
// arrow left
FVector2D ArrowSize = ArrowBrushes[(uint8)EArrowDirection::Left]->GetImageSize();
FVector2D TextPosition = FVector2D(GridCenter.X - (TextSize.X * .5f), CachedGridRectangle.Bottom + TextMargin + (ArrowSize.Y * .25f));
FVector2D ArrowPosition = FVector2D(TextPosition.X - ArrowSize.X - 10.f/* give padding*/, TextPosition.Y);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(ArrowSize, FSlateLayoutTransform(ArrowPosition)),
ArrowBrushes[(uint8)EArrowDirection::Left], ESlateDrawEffect::None, FLinearColor::White);
// Label
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(FVector2D(1.0f, 1.0f), FSlateLayoutTransform(TextPosition)).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
// arrow right
ArrowSize = ArrowBrushes[(uint8)EArrowDirection::Right]->GetImageSize();
ArrowPosition = FVector2D(TextPosition.X + TextSize.X + 10.f/* give padding*/, TextPosition.Y);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(ArrowSize, FSlateLayoutTransform(ArrowPosition)),
ArrowBrushes[(uint8)EArrowDirection::Right], ESlateDrawEffect::None, FLinearColor::White);
Text = FString::SanitizeFloat(SampleValueMin.X);
TextSize = FontMeasure->Measure(Text, FontInfo);
// Minimum value
FVector2D MinTextPosition(CachedGridRectangle.Left - (TextSize.X * .5f), CachedGridRectangle.Bottom + TextMargin + (TextSize.Y * .25f));
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(FVector2D(1.0f, 1.0f), FSlateLayoutTransform(MinTextPosition)).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
Text = FString::SanitizeFloat(SampleValueMax.X);
TextSize = FontMeasure->Measure(Text, FontInfo);
// Maximum value
FVector2D MaxTextPosition(CachedGridRectangle.Right - (TextSize.X * .5f), CachedGridRectangle.Bottom + TextMargin + (TextSize.Y * .25f));
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(FVector2D(1.0f, 1.0f), FSlateLayoutTransform(MaxTextPosition)).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
// Only draw Y axis labels if this is a 2D grid
if (GridType == EGridType::TwoAxis)
{
// Y axis
Text = ParameterYName.ToString();
TextSize = FontMeasure->Measure(Text, FontInfo);
// arrow up
ArrowSize = ArrowBrushes[(uint8)EArrowDirection::Up]->GetImageSize();
TextPosition = FVector2D(((GridMargin.Left - TextSize.X) * 0.5f - (ArrowSize.X * .25f)) + GridRatioMargin.Left, GridCenter.Y - (TextSize.Y * .5f));
ArrowPosition = FVector2D(TextPosition.X + TextSize.X * 0.5f - ArrowSize.X * 0.5f, TextPosition.Y - ArrowSize.Y - 10.f/* give padding*/);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(ArrowSize, FSlateLayoutTransform(ArrowPosition)),
ArrowBrushes[(uint8)EArrowDirection::Up], ESlateDrawEffect::None, FLinearColor::White);
// Label
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(FVector2D(1.0f, 1.0f), FSlateLayoutTransform(TextPosition)).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
// arrow down
ArrowSize = ArrowBrushes[(uint8)EArrowDirection::Down]->GetImageSize();
ArrowPosition = FVector2D(TextPosition.X + TextSize.X * 0.5f - ArrowSize.X * 0.5f, TextPosition.Y + TextSize.Y + 10.f/* give padding*/);
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(ArrowSize, FSlateLayoutTransform(ArrowPosition)),
ArrowBrushes[(uint8)EArrowDirection::Down], ESlateDrawEffect::None, FLinearColor::White);
Text = FString::SanitizeFloat(SampleValueMin.Y);
TextSize = FontMeasure->Measure(Text, FontInfo);
// Minimum value
FVector2D MinValuePosition(((GridMargin.Left - TextSize.X) * 0.5f - (TextSize.X * .25f)) + GridRatioMargin.Left, CachedGridRectangle.Bottom - (TextSize.Y * .5f));
FSlateDrawElement::MakeText(OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(
FVector2D(1.0f, 1.0f),
FSlateLayoutTransform(MinValuePosition)
).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
Text = FString::SanitizeFloat(SampleValueMax.Y);
TextSize = FontMeasure->Measure(Text, FontInfo);
// Maximum value
FSlateDrawElement::MakeText(OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(
FVector2D(1.0f, 1.0f), FSlateLayoutTransform( FVector2D( ((GridMargin.Left - TextSize.X) * 0.5f - (TextSize.X * .25f) ) + GridRatioMargin.Left, CachedGridRectangle.Top - (TextSize.Y * .5f)) )).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
}
DrawLayerId += 1;
}
//======================================================================================================================
void SBlendSpaceGridWidget::PaintGridSampleWeights(
const FGeometry& AllottedGeometry,
const FSlateRect& MyCullingRect,
FSlateWindowElementList& OutDrawElements,
int32& DrawLayerId) const
{
const UBlendSpace* BlendSpace = BlendSpaceBase.Get();
if (!BlendSpace)
{
return;
}
if (!BlendSpace->bInterpolateUsingGrid)
{
return;
}
const TSharedRef< FSlateFontMeasure > FontMeasure = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
const TArray<FEditorElement>& GridSamples = BlendSpace->GetGridSamples();
int32 NumGridSamples = GridSamples.Num();
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
for (int32 GridSampleIndex = 0 ; GridSampleIndex != NumGridSamples ; ++GridSampleIndex)
{
const FEditorElement& EditorElement = GridSamples[GridSampleIndex];
int32 TextOffset = 0;
for (int32 ElementIndex = 0 ; ElementIndex != 3 ; ++ElementIndex)
{
float SampleWeight = EditorElement.Weights[ElementIndex];
int32 SampleIndex = EditorElement.Indices[ElementIndex];
if (SampleWeight <= 0 || SampleIndex < 0)
{
continue;
}
const FBlendSample& Sample = Samples[SampleIndex];
const FText Name = FText::Format(LOCTEXT("SampleNameFormatWeight", "{0} ({1}) {2}"),
GetSampleName(Sample, SampleIndex), FText::AsNumber(SampleIndex), SampleWeight);
const FVector2D TextSize = FontMeasure->Measure(Name, FontInfo);
const FVector2D Padding = FVector2D(12.0f, 4.0f);
FVector GridSamplePosition = BlendSpace->GetGridPosition(GridSampleIndex);
// Show the sample name/index/weight, going progressively up (because sample labels are
// below the grid points)
FVector2D GridPosition = SampleValueToScreenPosition(GridSamplePosition);
GridPosition += FVector2D(-TextSize.X / 2, -2 * KeySize.Y);
GridPosition.Y -= TextSize.Y * TextOffset++;
GridPosition.X -= Padding.X / 2;
GridPosition.Y += Padding.Y / 2;
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 2, AllottedGeometry.MakeChild(FVector2f(1.0f, 1.0f),
FSlateLayoutTransform(GridPosition + Padding / 2)).ToPaintGeometry(), Name, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
}
}
}
//======================================================================================================================
void SBlendSpaceGridWidget::PaintTriangulation(
const FGeometry& AllottedGeometry,
const FSlateRect& MyCullingRect,
FSlateWindowElementList& OutDrawElements,
int32& DrawLayerId) const
{
const UBlendSpace* BlendSpace = BlendSpaceBase.Get();
if (!BlendSpace)
{
return;
}
if ((bReadOnly && BlendSpace->bInterpolateUsingGrid) || (!bReadOnly && !bShowTriangulation))
{
return;
}
TArray<FVector2D> PolygonPoints;
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
if (!BlendSpace->bInterpolateUsingGrid)
{
// Use runtime triangulation
const FBlendSpaceData& BlendSpaceData = BlendSpace->GetBlendSpaceData();
for (const FBlendSpaceSegment& Segment : BlendSpaceData.Segments)
{
int32 SampleIndex = Segment.SampleIndices[0];
int32 SampleIndex1 = Segment.SampleIndices[1];
TArray<FVector2D> Points;
Points.Add(SampleValueToScreenPosition(Samples[SampleIndex].SampleValue));
Points.Add(SampleValueToScreenPosition(Samples[SampleIndex1].SampleValue));
FSlateDrawElement::MakeLines(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.ToPaintGeometry(), Points,
ESlateDrawEffect::None, TriangulationColor.GetSpecifiedColor(), true, 0.5f);
}
const float CriticalDot = FMath::Cos(FMath::DegreesToRadians(CriticalTriangulationAngle));
for (const FBlendSpaceTriangle& Triangle : BlendSpaceData.Triangles)
{
FLinearColor TriangleFillColor = TriangulationCurrentColor.GetSpecifiedColor();
FLinearColor TriangleLineColor = TriangulationColor.GetSpecifiedColor();
TriangleFillColor.A = 0.03f; // Alpha for tinting the triangulation background
int32 TriangleLayer = DrawLayerId + 1;
FVector2D ScreenPositions[3] = {
SampleValueToScreenPosition(Samples[Triangle.SampleIndices[0]].SampleValue),
SampleValueToScreenPosition(Samples[Triangle.SampleIndices[1]].SampleValue),
SampleValueToScreenPosition(Samples[Triangle.SampleIndices[2]].SampleValue),
};
// Show invalid triangles even if there's only one triangle, because that probably
// happened when somebody failed to place the sample points in a proper line.
{
FVector2D NormalizedPositions[3] = {
SampleValueToNormalizedPosition(Samples[Triangle.SampleIndices[0]].SampleValue),
SampleValueToNormalizedPosition(Samples[Triangle.SampleIndices[1]].SampleValue),
SampleValueToNormalizedPosition(Samples[Triangle.SampleIndices[2]].SampleValue),
};
for (int32 Index = 0; Index != 3; ++Index)
{
FVector2D A = NormalizedPositions[(Index + 2) % 3] - NormalizedPositions[(Index + 1) % 3];
FVector2D B = NormalizedPositions[Index] - NormalizedPositions[(Index + 1) % 3];
double Dot = A.GetSafeNormal() | B.GetSafeNormal();
double Area = 0.5f * FMath::Abs(B ^ A);
if (Dot > CriticalDot || Area < CriticalTriangulationArea)
{
TriangleFillColor = FLinearColor::Red;
TriangleFillColor.A = 0.5f;
TriangleLineColor = FLinearColor::Red;
TriangleLayer = DrawLayerId + 10; // just bump it up so it definitely shows
}
}
}
FVector2D MidPoint(0, 0);
PolygonPoints.Empty(3);
for (int32 Index0 = 0; Index0 != FBlendSpaceTriangle::NUM_VERTICES; ++Index0)
{
int32 Index1 = (Index0 + 1) % FBlendSpaceTriangle::NUM_VERTICES;
int32 Index2 = (Index0 + 2) % FBlendSpaceTriangle::NUM_VERTICES;
int32 SampleIndex0 = Triangle.SampleIndices[Index0];
int32 SampleIndex1 = Triangle.SampleIndices[Index1];
int32 SampleIndex2 = Triangle.SampleIndices[Index2];
TArray<FVector2D> Points = { ScreenPositions[Index0], ScreenPositions[Index1] };
MidPoint += SampleValueToScreenPosition(Samples[SampleIndex0].SampleValue) / 3.0f;
FSlateDrawElement::MakeLines(
OutDrawElements, TriangleLayer, AllottedGeometry.ToPaintGeometry(), Points,
ESlateDrawEffect::None, TriangleLineColor, true, 0.5f);
PolygonPoints.Push(ScreenPositions[Index0]);
}
PaintTriangle(PolygonPoints[0], PolygonPoints[1], PolygonPoints[2], AllottedGeometry,
TriangleFillColor, LabelBrush, OutDrawElements, DrawLayerId);
#ifdef DEBUG_BLENDSPACE_TRIANGULATION
// Draw the adjacent triangle indices around the perimeter
if (!bSamplePreviewing)
{
for (int32 Index0 = 0; Index0 != FBlendSpaceTriangle::NUM_VERTICES; ++Index0)
{
if (Triangle.EdgeInfo[Index0].NeighbourTriangleIndex < 0)
{
int32 Index1 = (Index0 + 1) % FBlendSpaceTriangle::NUM_VERTICES;
FVector2D MidEdge = ( ScreenPositions[Index0] + ScreenPositions[Index1]) * 0.5;
float PullInAmount = 0.2;
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(
FMath::Lerp(ScreenPositions[Index0], MidEdge, PullInAmount), FVector2D(1.0f, 1.0f)).ToPaintGeometry(),
FText::AsNumber(Triangle.EdgeInfo[Index0].AdjacentPerimeterTriangleIndices[0]),
FontInfo, ESlateDrawEffect::None, FLinearColor::Red);
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(
FMath::Lerp(ScreenPositions[Index1], MidEdge, PullInAmount), FVector2D(1.0f, 1.0f)).ToPaintGeometry(),
FText::AsNumber(Triangle.EdgeInfo[Index0].AdjacentPerimeterTriangleIndices[1]),
FontInfo, ESlateDrawEffect::None, FLinearColor::Red);
}
}
}
#endif
#ifdef DEBUG_BLENDSPACE_TRIANGULATION
// Draw the triangle indices for debugging
FText Text = FText::AsNumber(&Triangle - &BlendSpaceData.Triangles[0]);
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(
FVector2D(MidPoint.X, MidPoint.Y), FVector2D(1.0f, 1.0f)).ToPaintGeometry(),
Text, FontInfo, ESlateDrawEffect::None, FLinearColor::Gray);
#endif
}
}
// Draw the current triangle (or polygon)
if (bSamplePreviewing && FSlateApplication::Get().GetModifierKeys().IsAltDown())
{
PolygonPoints.Empty(3);
for (const FBlendSampleData& PreviewedSample : PreviewedSamples)
{
float Weight = PreviewedSample.TotalWeight;
if (Weight)
{
int32 SampleIndex = PreviewedSample.SampleDataIndex;
FVector2D Point = SampleValueToScreenPosition(Samples[SampleIndex].SampleValue);
PolygonPoints.Push(Point);
}
}
if (PolygonPoints.Num())
{
FLinearColor FillColor = TriangulationCurrentColor.GetSpecifiedColor();
FillColor.A = 0.2f; // Alpha for the current triangulation triangle
FLinearColor OutlineColor = FillColor;
OutlineColor.A = 0.5f;
PaintPolygon(PolygonPoints, AllottedGeometry, FillColor, OutlineColor, LabelBrush, OutDrawElements, DrawLayerId);
}
}
DrawLayerId += 1;
}
FText SBlendSpaceGridWidget::GetSampleName(const FBlendSample& InBlendSample, int32 InSampleIndex) const
{
if(OnGetBlendSpaceSampleName.IsBound())
{
return FText::FromName(OnGetBlendSpaceSampleName.Execute(InSampleIndex));
}
else
{
if(InBlendSample.Animation != nullptr)
{
return FText::FromString(InBlendSample.Animation->GetName());
}
}
return LOCTEXT("NoAnimationSetTooltipText", "No Animation Set");
}
void SBlendSpaceGridWidget::PaintAnimationNames(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32& DrawLayerId) const
{
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
const TSharedRef< FSlateFontMeasure > FontMeasure = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
for (int32 SampleIndex = 0; SampleIndex < Samples.Num(); ++SampleIndex)
{
const FBlendSample& Sample = Samples[SampleIndex];
const FText Name = FText::Format(LOCTEXT("SampleNameFormat", "{0} ({1})"), GetSampleName(Sample, SampleIndex), FText::AsNumber(SampleIndex));
const FVector2D TextSize = FontMeasure->Measure(Name, FontInfo);
const FVector2D Padding = FVector2D(12.0f, 4.0f);
FVector2D GridPosition = SampleValueToScreenPosition(Sample.SampleValue);
GridPosition += FVector2D(-TextSize.X / 2, KeySize.Y / 2);
GridPosition.X -= Padding.X / 2;
GridPosition.Y += Padding.Y / 2;
FSlateDrawElement::MakeBox(
OutDrawElements, DrawLayerId + 1, AllottedGeometry.MakeChild(TextSize + Padding, FSlateLayoutTransform(GridPosition)).ToPaintGeometry(),
LabelBrush, ESlateDrawEffect::None, FLinearColor::Black);
FSlateDrawElement::MakeText(
OutDrawElements, DrawLayerId + 2, AllottedGeometry.MakeChild(FVector2D(1.0f, 1.0f), FSlateLayoutTransform(GridPosition + Padding/2)).ToPaintGeometry(),
Name, FontInfo, ESlateDrawEffect::None, FLinearColor::White);
}
}
DrawLayerId += 2;
}
FReply SBlendSpaceGridWidget::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
// Check if we are in dropping state and if so snap to the grid and try to add the sample
if (DragState == EDragState::DragDrop || DragState == EDragState::InvalidDragDrop || DragState == EDragState::DragDropOverride)
{
if (DragState == EDragState::DragDrop)
{
TSharedPtr<FAssetDragDropOp> DragDropOperation = DragDropEvent.GetOperationAs<FAssetDragDropOp>();
if (DragDropOperation.IsValid())
{
const FVector SampleValue = ScreenPositionToSampleValueWithSnapping(
LocalMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown());
const TArray<FAssetData>& Assets = DragDropOperation->GetAssets();
for (int Index = 0 ; Index != Assets.Num() ; ++Index)
{
const FAssetData& AssetData = Assets[Index];
UObject* Asset = AssetData.GetAsset();
UAnimSequence* Animation = (UAnimSequence*) Asset;
if (OnSampleAdded.IsBound())
{
OnSampleAdded.Execute(Animation, SampleValue, true);
}
}
}
}
else if (DragState == EDragState::DragDropOverride)
{
TSharedPtr<FAssetDragDropOp> DragDropOperation = DragDropEvent.GetOperationAs<FAssetDragDropOp>();
if (DragDropOperation.IsValid())
{
UAnimSequence* Animation = FAssetData::GetFirstAsset<UAnimSequence>(DragDropOperation->GetAssets());
int32 DroppedSampleIndex = GetClosestSamplePointIndexToMouse();
OnSampleReplaced.ExecuteIfBound(DroppedSampleIndex, Animation);
}
}
DragState = EDragState::None;
}
DragDropAnimationSequence = nullptr;
DragDropAnimationName = FText::GetEmpty();
HoveredAnimationName = FText::GetEmpty();
}
return FReply::Unhandled();
}
void SBlendSpaceGridWidget::OnDragEnter(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (DragDropEvent.GetOperationAs<FAssetDragDropOp>().IsValid())
{
DragState = IsValidDragDropOperation(DragDropEvent, InvalidDragDropText) ? EDragState::DragDrop : EDragState::InvalidDragDrop;
}
}
}
FReply SBlendSpaceGridWidget::OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (DragState == EDragState::DragDrop || DragState == EDragState::InvalidDragDrop || DragState == EDragState::DragDropOverride)
{
LocalMousePosition = MyGeometry.AbsoluteToLocal(DragDropEvent.GetScreenSpacePosition());
// Always update the tool tip, in case it became invalid
TSharedPtr<FAssetDragDropOp> DragDropOperation = DragDropEvent.GetOperationAs<FAssetDragDropOp>();
if (DragDropOperation.IsValid())
{
DragDropOperation->SetToolTip(GetToolTipSampleValue(), DragDropOperation->GetIcon());
}
return FReply::Handled();
}
}
return FReply::Unhandled();
}
void SBlendSpaceGridWidget::OnDragLeave(const FDragDropEvent& DragDropEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (DragState == EDragState::DragDrop || DragState == EDragState::InvalidDragDrop || DragState == EDragState::DragDropOverride)
{
DragState = EDragState::None;
DragDropAnimationSequence = nullptr;
DragDropAnimationName = FText::GetEmpty();
HoveredAnimationName = FText::GetEmpty();
}
}
}
FReply SBlendSpaceGridWidget::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (this->HasMouseCapture())
{
if (DragState == EDragState::None || DragState == EDragState::PreDrag)
{
ProcessClick(MyGeometry, MouseEvent);
}
else if (DragState == EDragState::DragSample)
{
// Process drag ending
ResetToolTip();
OnSampleMoved.ExecuteIfBound(DraggedSampleIndex, LastDragPosition, false);
}
// Reset drag state and index
DragState = EDragState::None;
DraggedSampleIndex = INDEX_NONE;
return FReply::Handled().ReleaseMouseCapture();
}
else
{
return ProcessClick(MyGeometry, MouseEvent);
}
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
// If we are over a sample, make it our currently (dragged) sample
if (HighlightedSampleIndex != INDEX_NONE)
{
DraggedSampleIndex = SelectedSampleIndex = HighlightedSampleIndex;
HighlightedSampleIndex = INDEX_NONE;
ResetToolTip();
DragState = EDragState::PreDrag;
MouseDownPosition = LocalMousePosition;
// Start mouse capture
return FReply::Handled().CaptureMouse(SharedThis(this));
}
}
return FReply::Handled();
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::OnMouseButtonDoubleClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
if (SelectedSampleIndex != INDEX_NONE)
{
OnSampleDoubleClicked.ExecuteIfBound(SelectedSampleIndex);
}
else
{
OnCanvasDoubleClicked.ExecuteIfBound();
}
return FReply::Handled();
}
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
EnableStatusBarMessage(true);
}
// Cache the mouse position in local and screen space
LocalMousePosition = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
LastMousePosition = MouseEvent.GetScreenSpacePosition();
if(!bReadOnly)
{
if (this->HasMouseCapture())
{
if (DragState == EDragState::None)
{
if (HighlightedSampleIndex != INDEX_NONE)
{
DragState = EDragState::DragSample;
DraggedSampleIndex = HighlightedSampleIndex;
HighlightedSampleIndex = INDEX_NONE;
return FReply::Handled();
}
}
else if (DragState == EDragState::PreDrag)
{
// Actually start dragging
if ((LocalMousePosition - MouseDownPosition).SizeSquared() > DragThreshold)
{
DragState = EDragState::DragSample;
HighlightedSampleIndex = INDEX_NONE;
ShowToolTip();
return FReply::Handled();
}
}
}
else if (IsHovered() && bMouseIsOverGeometry)
{
if (MouseEvent.IsControlDown())
{
StartPreviewing();
DragState = EDragState::Preview;
// Make tool tip visible (this will display the current preview sample value)
ShowToolTip();
// Set flag for showing advanced preview info in tooltip
bAdvancedPreview = MouseEvent.IsAltDown();
return FReply::Handled();
}
else if(TargetPosition.IsSet())
{
StartPreviewing();
DragState = EDragState::None;
ShowToolTip();
// Set flag for showing advanced preview info in tooltip
bAdvancedPreview = MouseEvent.IsAltDown();
return FReply::Handled();
}
else if (bSamplePreviewing)
{
StopPreviewing();
DragState = EDragState::None;
ResetToolTip();
return FReply::Handled();
}
}
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::ProcessClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
SelectedSampleIndex = INDEX_NONE;
if (HighlightedSampleIndex == INDEX_NONE)
{
// If there isn't any sample currently being highlighted, retrieve all of them and see if we are over one
SelectedSampleIndex = GetClosestSamplePointIndexToMouse();
}
else
{
// If we are over a sample, make it the selected sample index
SelectedSampleIndex = HighlightedSampleIndex;
HighlightedSampleIndex = INDEX_NONE;
}
}
else if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
{
auto PushMenu = [this, &MouseEvent](TSharedPtr<SWidget> InMenuContent)
{
if (InMenuContent.IsValid())
{
const FWidgetPath WidgetPath = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
const FVector2D MousePosition = MouseEvent.GetScreenSpacePosition();
// This is of a fixed size atm since MenuContent->GetDesiredSize() will not take the detail
// customization into account and return an incorrect (small) size
const FVector2D ExpectedSize(300, 300);
const FVector2D MenuPosition = FSlateApplication::Get().CalculatePopupWindowPosition(
FSlateRect(static_cast<float>(MousePosition.X), static_cast<float>(MousePosition.Y), static_cast<float>(MousePosition.X), static_cast<float>(MousePosition.Y)), ExpectedSize, false);
FSlateApplication::Get().PushMenu(
AsShared(),
WidgetPath,
InMenuContent.ToSharedRef(),
MenuPosition,
FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu)
);
}
};
// If we are over a sample open a context menu for editing its data
if (HighlightedSampleIndex != INDEX_NONE)
{
SelectedSampleIndex = HighlightedSampleIndex;
// Create context menu
TSharedPtr<SWidget> MenuContent = CreateBlendSampleContextMenu();
// Reset highlight sample index
HighlightedSampleIndex = INDEX_NONE;
PushMenu(MenuContent);
return FReply::Handled().SetUserFocus(MenuContent.ToSharedRef(), EFocusCause::SetDirectly).ReleaseMouseCapture();
}
else
{
TSharedPtr<SWidget> MenuContent = CreateNewBlendSampleContextMenu(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition()));
PushMenu(MenuContent);
return FReply::Handled().SetUserFocus(MenuContent.ToSharedRef(), EFocusCause::SetDirectly).ReleaseMouseCapture();
}
}
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
if (UICommandList->ProcessCommandBindings(InKeyEvent))
{
return FReply::Handled();
}
// Start previewing when either one of the shift keys is pressed
if (IsHovered() && bMouseIsOverGeometry)
{
if ((InKeyEvent.GetKey() == EKeys::LeftControl) || (InKeyEvent.GetKey() == EKeys::RightControl))
{
StartPreviewing();
DragState = EDragState::Preview;
// Make tool tip visible (this will display the current preview sample value)
ShowToolTip();
return FReply::Handled();
}
// Set flag for showing advanced preview info in tooltip
if ((InKeyEvent.GetKey() == EKeys::LeftAlt) || (InKeyEvent.GetKey() == EKeys::RightAlt))
{
bAdvancedPreview = true;
return FReply::Handled();
}
if (InKeyEvent.GetKey() == EKeys::PageUp)
{
OnNavigateUp.ExecuteIfBound();
return FReply::Handled();
}
else if (InKeyEvent.GetKey() == EKeys::PageDown)
{
OnNavigateDown.ExecuteIfBound();
return FReply::Handled();
}
}
}
return FReply::Unhandled();
}
FReply SBlendSpaceGridWidget::OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
if(!bReadOnly && BlendSpaceBase.IsSet())
{
// Stop previewing when shift keys are released
if ((InKeyEvent.GetKey() == EKeys::LeftControl) || (InKeyEvent.GetKey() == EKeys::RightControl))
{
StopPreviewing();
DragState = EDragState::None;
ResetToolTip();
return FReply::Handled();
}
if((InKeyEvent.GetKey() == EKeys::LeftAlt) || (InKeyEvent.GetKey() == EKeys::RightAlt))
{
bAdvancedPreview = false;
return FReply::Handled();
}
// Pressing esc will remove the current key selection
if( InKeyEvent.GetKey() == EKeys::Escape)
{
SelectedSampleIndex = INDEX_NONE;
}
}
return FReply::Unhandled();
}
void SBlendSpaceGridWidget::MakeViewContextMenuEntries(FMenuBuilder& InMenuBuilder)
{
InMenuBuilder.BeginSection("ViewOptions", LOCTEXT("ViewOptionsMenuHeader", "View Options"));
{
if (GetTriangulationButtonVisibility() == EVisibility::Visible)
{
TAttribute<FText> ShowTriangulation = TAttribute<FText>::Create(
[this]()
{
return (BlendSpaceBase.Get() && BlendSpaceBase.Get()->bInterpolateUsingGrid)
? LOCTEXT("ShowGridToSampleConnections", "Show Grid/Sample Connections")
: LOCTEXT("ShowTriangulation", "Show Triangulation");
});
TAttribute<FText> ShowTriangulationToolTip = TAttribute<FText>::Create(
[this]()
{
return (BlendSpaceBase.Get() && BlendSpaceBase.Get()->bInterpolateUsingGrid)
? LOCTEXT("ShowGridToSampleConnectionsToolTip", "Show which samples each grid point is associated with")
: LOCTEXT("ShowTriangulationToolTip", "Show the Delaunay triangulation for all blend space samples");
});
InMenuBuilder.AddMenuEntry(
ShowTriangulation,
ShowTriangulationToolTip,
FSlateIcon(FAppStyle::GetAppStyleSetName(), "BlendSpaceEditor.ToggleTriangulation"),
FUIAction(
FExecuteAction::CreateLambda([this](){ bShowTriangulation = !bShowTriangulation; }),
FCanExecuteAction(),
FGetActionCheckState::CreateLambda([this](){ return bShowTriangulation ? ECheckBoxState::Checked : ECheckBoxState::Unchecked; })
),
NAME_None,
EUserInterfaceActionType::ToggleButton
);
}
InMenuBuilder.AddMenuEntry(
LOCTEXT("ShowAnimationNames", "Show Sample Names"),
LOCTEXT("ShowAnimationNamesToolTip", "Show the names of each of the samples"),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "BlendSpaceEditor.ToggleLabels"),
FUIAction(
FExecuteAction::CreateLambda([this](){ bShowAnimationNames = !bShowAnimationNames; }),
FCanExecuteAction(),
FGetActionCheckState::CreateLambda([this](){ return bShowAnimationNames ? ECheckBoxState::Checked : ECheckBoxState::Unchecked; })
),
NAME_None,
EUserInterfaceActionType::ToggleButton
);
InMenuBuilder.AddMenuEntry(
LOCTEXT("StretchFittingText", "Stretch Grid to Fit"),
LOCTEXT("StretchFittingTextToolTip", "Whether to stretch the grid to fit or to fit the grid to the largest axis"),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "BlendSpaceEditor.ZoomToFit"),
FUIAction(
FExecuteAction::CreateLambda([this](){ ToggleFittingType(); }),
FCanExecuteAction(),
FGetActionCheckState::CreateLambda([this](){ return bStretchToFit ? ECheckBoxState::Checked : ECheckBoxState::Unchecked; })
),
NAME_None,
EUserInterfaceActionType::ToggleButton
);
}
InMenuBuilder.EndSection();
}
TSharedPtr<SWidget> SBlendSpaceGridWidget::CreateBlendSampleContextMenu()
{
const bool bShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bShouldCloseWindowAfterMenuSelection, UICommandList);
TSharedPtr<IStructureDetailsView> StructureDetailsView;
// Initialize details view
FDetailsViewArgs DetailsViewArgs;
{
DetailsViewArgs.bAllowSearch = false;
DetailsViewArgs.bHideSelectionTip = true;
DetailsViewArgs.bLockable = false;
DetailsViewArgs.bSearchInitialKeyFocus = true;
DetailsViewArgs.bUpdatesFromSelection = false;
DetailsViewArgs.NotifyHook = NotifyHook;
DetailsViewArgs.bShowOptions = true;
DetailsViewArgs.bShowModifiedPropertiesOption = false;
}
FStructureDetailsViewArgs StructureViewArgs;
{
StructureViewArgs.bShowObjects = true;
StructureViewArgs.bShowAssets = true;
StructureViewArgs.bShowClasses = true;
StructureViewArgs.bShowInterfaces = true;
}
StructureDetailsView = FModuleManager::GetModuleChecked<FPropertyEditorModule>("PropertyEditor")
.CreateStructureDetailView(DetailsViewArgs, StructureViewArgs, nullptr, LOCTEXT("SampleData", "Blend Sample"));
{
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
const FBlendSample& Sample = BlendSpace->GetBlendSample(HighlightedSampleIndex);
StructureDetailsView->GetDetailsView()->SetGenericLayoutDetailsDelegate(
FOnGetDetailCustomizationInstance::CreateStatic(
&FBlendSampleDetails::MakeInstance, BlendSpace, this, HighlightedSampleIndex));
FStructOnScope* Struct = new FStructOnScope(FBlendSample::StaticStruct(), (uint8*)&Sample);
Struct->SetPackage(BlendSpace->GetOutermost());
StructureDetailsView->SetStructureData(MakeShareable(Struct));
}
}
MenuBuilder.BeginSection("Sample", LOCTEXT("SampleMenuHeader", "Sample"));
{
MenuBuilder.AddMenuEntry(FGenericCommands::Get().Cut);
MenuBuilder.AddMenuEntry(FGenericCommands::Get().Copy);
MenuBuilder.AddMenuEntry(FGenericCommands::Get().Delete);
MenuBuilder.AddWidget(StructureDetailsView->GetWidget().ToSharedRef(), FText::GetEmpty(), true);
}
MenuBuilder.EndSection();
MakeViewContextMenuEntries(MenuBuilder);
return MenuBuilder.MakeWidget();
}
TSharedPtr<SWidget> SBlendSpaceGridWidget::CreateNewBlendSampleContextMenu(const FVector2D& InMousePosition)
{
const bool bShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bShouldCloseWindowAfterMenuSelection, UICommandList);
FVector NewSampleValue;
if(FSlateApplication::Get().GetModifierKeys().IsShiftDown())
{
NewSampleValue = ScreenPositionToSampleValue(SnapScreenPositionToGrid(InMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown()), false);
}
else
{
const FVector2D GridPosition(FMath::Clamp(InMousePosition.X, CachedGridRectangle.Left, CachedGridRectangle.Right),
FMath::Clamp(InMousePosition.Y, CachedGridRectangle.Top, CachedGridRectangle.Bottom));
NewSampleValue = ScreenPositionToSampleValue(GridPosition, false);
}
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
MenuBuilder.BeginSection("Sample", LOCTEXT("SampleMenuHeader", "Sample"));
{
MenuBuilder.AddMenuEntry(FGenericCommands::Get().Paste);
MenuBuilder.AddMenuEntry(FGenericCommands::Get().Delete);
if(!BlendSpace->IsAsset())
{
// Blend space graph - add a new graph sample
MenuBuilder.AddMenuEntry(
LOCTEXT("AddNewSample", "Add New Sample"),
LOCTEXT("AddNewSampleTooltip", "Add a new sample to the blendspace at this location"),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "Icons.Plus"),
FUIAction(
FExecuteAction::CreateLambda(
[this, NewSampleValue]()
{
if (OnSampleAdded.IsBound())
{
OnSampleAdded.Execute(nullptr, NewSampleValue, false);
}
})
)
);
}
}
MenuBuilder.EndSection();
}
MakeViewContextMenuEntries(MenuBuilder);
return MenuBuilder.MakeWidget();
}
FReply SBlendSpaceGridWidget::ToggleTriangulationVisibility()
{
bShowTriangulation = !bShowTriangulation;
return FReply::Handled();
}
void SBlendSpaceGridWidget::CalculateGridPoints()
{
CachedGridPoints.Empty(SampleGridDivisions.X * SampleGridDivisions.Y);
CachedSamplePoints.Empty(SampleGridDivisions.X * SampleGridDivisions.Y);
if (SampleGridDivisions.X <= 0 || (GridType == EGridType::TwoAxis && SampleGridDivisions.Y <= 0))
{
return;
}
for (int32 GridY = 0; GridY < ((GridType == EGridType::TwoAxis) ? SampleGridDivisions.Y + 1 : 1); ++GridY)
{
for (int32 GridX = 0; GridX < SampleGridDivisions.X + 1; ++GridX)
{
// Calculate grid point in 0-1 form
FVector2D GridPoint(
GridX * (1.0f / SampleGridDivisions.X),
(GridType == EGridType::TwoAxis) ? GridY * (1.0f / SampleGridDivisions.Y) : 0.5f);
// Multiply with size and offset according to the grid layout
GridPoint *= CachedGridRectangle.GetSize();
GridPoint += CachedGridRectangle.GetTopLeft();
CachedGridPoints.Add(GridPoint);
CachedSamplePoints.Add(FVector(
SampleValueMin.X + (GridX * (SampleValueRange.X / SampleGridDivisions.X)),
(GridType == EGridType::TwoAxis) ? SampleValueMax.Y - (GridY * (SampleValueRange.Y / SampleGridDivisions.Y)) : 0.0f,
0.0f));
}
}
}
const FVector2D SBlendSpaceGridWidget::SnapScreenPositionToGrid(const FVector2D& InPosition, bool bForceSnap) const
{
const int32 GridPointIndex = FindClosestGridPointIndexFromScreenPosition(InPosition);
const FVector2D& GridPoint = CachedGridPoints[GridPointIndex];
const bool bSnapX = bForceSnap || bSampleSnapToGrid[0];
const bool bSnapY = bForceSnap || bSampleSnapToGrid[1];
return FVector2D
{
bSnapX ? GridPoint.X : InPosition.X,
bSnapY ? GridPoint.Y : InPosition.Y
};
}
const FVector SBlendSpaceGridWidget::ScreenPositionToSampleValueWithSnapping(const FVector2D& InPosition, bool bForceSnap) const
{
FVector SampleValue = ScreenPositionToSampleValue(InPosition, true);
const int32 GridPointIndex = FindClosestGridPointIndexFromScreenPosition(InPosition);
const FVector GridPos = CachedSamplePoints[GridPointIndex];
const bool bSnapX = bForceSnap || bSampleSnapToGrid[0];
const bool bSnapY = bForceSnap || bSampleSnapToGrid[1];
return FVector
{
bSnapX ? GridPos.X : SampleValue.X,
bSnapY ? GridPos.Y : SampleValue.Y,
0.f
};
}
int32 SBlendSpaceGridWidget::FindClosestGridPointIndexFromScreenPosition(const FVector2D& InPosition) const
{
// Clamp the screen position to the grid
const FVector2D GridPosition(
FMath::Clamp(InPosition.X, CachedGridRectangle.Left, CachedGridRectangle.Right),
FMath::Clamp(InPosition.Y, CachedGridRectangle.Top, CachedGridRectangle.Bottom));
// Find the closest grid point
double Distance = TNumericLimits<double>::Max();
int32 GridPointIndex = INDEX_NONE;
for (int32 Index = 0; Index < CachedGridPoints.Num(); ++Index)
{
const FVector2D& GridPoint = CachedGridPoints[Index];
const double DistanceToGrid = FVector2D::DistSquared(GridPosition, GridPoint);
if (DistanceToGrid < Distance)
{
Distance = DistanceToGrid;
GridPointIndex = Index;
}
}
checkf(GridPointIndex != INDEX_NONE, TEXT("Unable to find gridpoint"));
return GridPointIndex;
}
const FVector2D SBlendSpaceGridWidget::SampleValueToNormalizedPosition(const FVector& SampleValue) const
{
// Convert the sample value to 0 to 1 form
FVector2D NormalizedPosition(
((SampleValue.X - SampleValueMin.X) / SampleValueRange.X),
GridType == EGridType::TwoAxis ? ((SampleValueMax.Y - SampleValue.Y) / SampleValueRange.Y) : 0.5f);
return NormalizedPosition;
}
const FVector2D SBlendSpaceGridWidget::SampleValueToScreenPosition(const FVector& SampleValue) const
{
const FVector2D NormalizedPosition = SampleValueToNormalizedPosition(SampleValue);
const FVector2D GridSize = CachedGridRectangle.GetSize();
const FVector2D GridCorner = CachedGridRectangle.GetCenter() - 0.5f * GridSize;
const FVector2D ScreenPosition = GridCorner + NormalizedPosition * CachedGridRectangle.GetSize();
return ScreenPosition;
}
const FVector SBlendSpaceGridWidget::ScreenPositionToSampleValue(const FVector2D& ScreenPosition, bool bClamp) const
{
FVector2D LocalGridPosition = ScreenPosition;
// Move to center of grid and convert to 0 - 1 form
LocalGridPosition -= CachedGridRectangle.GetCenter();
LocalGridPosition /= (CachedGridRectangle.GetSize() * 0.5f);
LocalGridPosition += FVector2D::UnitVector;
LocalGridPosition *= 0.5f;
// Calculate the sample value by mapping it to the blend parameter range
FVector SampleValue
(
(LocalGridPosition.X * SampleValueRange.X) + SampleValueMin.X,
(GridType == EGridType::TwoAxis) ? SampleValueMax.Y - (LocalGridPosition.Y * SampleValueRange.Y) : 0.0f,
0.f
);
if (bClamp)
{
SampleValue.X = FMath::Clamp(SampleValue.X, SampleValueMin.X, SampleValueMax.X);
SampleValue.Y = FMath::Clamp(SampleValue.Y, SampleValueMin.Y, SampleValueMax.Y);
}
return SampleValue;
}
const FSlateRect SBlendSpaceGridWidget::GetGridRectangleFromGeometry(const FGeometry& MyGeometry)
{
const float TopOffset = bReadOnly ? 0.0f : 20.0f; // Ideally we'd get the size of the buttons (showing the label/triangulation etc)
FSlateRect WindowRect = FSlateRect(0, TopOffset, static_cast<float>(MyGeometry.GetLocalSize().X), static_cast<float>(MyGeometry.GetLocalSize().Y));
if (!bStretchToFit)
{
UpdateGridRatioMargin(WindowRect.GetSize());
}
return WindowRect.InsetBy(GridMargin + GridRatioMargin);
}
bool SBlendSpaceGridWidget::IsSampleValueWithinMouseRange(const FVector& SampleValue, float& OutDistance) const
{
const FVector2D GridPosition = SampleValueToScreenPosition(SampleValue);
OutDistance = static_cast<float>(FVector2D::Distance(LocalMousePosition, GridPosition));
return (OutDistance < ClickAndHighlightThreshold);
}
int32 SBlendSpaceGridWidget::GetClosestSamplePointIndexToMouse() const
{
float BestDistance = FLT_MAX;
int32 BestIndex = INDEX_NONE;
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
for (int32 SampleIndex = 0; SampleIndex < Samples.Num(); ++SampleIndex)
{
const FBlendSample& Sample = Samples[SampleIndex];
float Distance;
if (IsSampleValueWithinMouseRange(Sample.SampleValue, Distance))
{
if(Distance < BestDistance)
{
BestDistance = Distance;
BestIndex = SampleIndex;
}
}
}
}
return BestIndex;
}
void SBlendSpaceGridWidget::StartPreviewing()
{
bSamplePreviewing = true;
LastPreviewingMousePosition = LocalMousePosition;
}
void SBlendSpaceGridWidget::StopPreviewing()
{
bSamplePreviewing = false;
}
FText SBlendSpaceGridWidget::GetToolTipSampleValidity() const
{
const UBlendSpace* BlendSpace = BlendSpaceBase.Get();
FText ToolTipText = FText::GetEmpty();
if (!bReadOnly && BlendSpace && BlendSpace->bInterpolateUsingGrid)
{
int32 SampleIndex = INDEX_NONE;
if (DragState == EDragState::None)
{
SampleIndex = HighlightedSampleIndex;
}
else if (DragState == EDragState::DragSample)
{
SampleIndex = DraggedSampleIndex;
}
else
{
SampleIndex = INDEX_NONE;
}
if (SampleIndex != INDEX_NONE && BlendSpace->IsValidBlendSampleIndex(SampleIndex))
{
float SampleLookupWeight = GetSampleLookupWeight(SampleIndex);
if (SampleLookupWeight >= 1.0f)
{
return ToolTipText;
}
else if (SampleLookupWeight <= 0.0f)
{
ToolTipText = FText::Format(
LOCTEXT("SampleValidityZero", "Self weight is zero"),
SampleLookupWeight);
}
else if (SampleLookupWeight <= SampleLookupWeightThreshold)
{
ToolTipText = FText::Format(
LOCTEXT("SampleValidityLow", "Self weight is low: {0}"),
SampleLookupWeight);
}
else if (SampleLookupWeight < 1.0f)
{
ToolTipText = FText::Format(
LOCTEXT("SampleValidity", "Self weight: {0}"),
SampleLookupWeight);
}
}
}
return ToolTipText;
}
FText SBlendSpaceGridWidget::GetToolTipAnimationName() const
{
FText ToolTipText = FText::GetEmpty();
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
const FText PreviewValue = LOCTEXT("PreviewValueTooltip", "Preview Value");
if(bReadOnly)
{
ToolTipText = PreviewValue;
}
else
{
switch (DragState)
{
// If we are not dragging, but over a valid blend sample return its animation asset name
case EDragState::None:
{
if (bHighlightPreviewPin)
{
ToolTipText = PreviewValue;
}
else if (HighlightedSampleIndex != INDEX_NONE && BlendSpace->IsValidBlendSampleIndex(HighlightedSampleIndex))
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(HighlightedSampleIndex);
ToolTipText = GetSampleName(BlendSample, HighlightedSampleIndex);
}
else if(TargetPosition.IsSet())
{
ToolTipText = PreviewValue;
}
break;
}
case EDragState::PreDrag:
{
break;
}
// If we are dragging a sample return the dragged sample's animation asset name
case EDragState::DragSample:
{
if (BlendSpace->IsValidBlendSampleIndex(DraggedSampleIndex))
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(DraggedSampleIndex);
ToolTipText = GetSampleName(BlendSample, DraggedSampleIndex);
}
break;
}
// If we are performing a drag/drop operation return the cached operation animation name
case EDragState::DragDrop:
{
ToolTipText = DragDropAnimationName;
break;
}
case EDragState::DragDropOverride:
{
ToolTipText = DragDropAnimationName;
break;
}
case EDragState::InvalidDragDrop:
{
break;
}
// If we are previewing return a descriptive label
case EDragState::Preview:
{
ToolTipText = PreviewValue;
break;
}
default:
check(false);
}
}
}
return ToolTipText;
}
FText SBlendSpaceGridWidget::GetToolTipSampleValue() const
{
FText ToolTipText = FText::GetEmpty();
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
static const FTextFormat OneAxisFormat = LOCTEXT("OneAxisFormat", "{0}: {1}");
static const FTextFormat TwoAxisFormat = LOCTEXT("TwoAxisFormat", "{0}: {1} {2}: {3}");
const FTextFormat& ValueFormattingText = (GridType == EGridType::TwoAxis) ? TwoAxisFormat : OneAxisFormat;
auto AddAdvancedPreview = [this, &ToolTipText, BlendSpace]()
{
FTextBuilder TextBuilder;
TextBuilder.AppendLine(ToolTipText);
if (bAdvancedPreview)
{
for (const FBlendSampleData& SampleData : PreviewedSamples)
{
if(BlendSpace->IsValidBlendSampleIndex(SampleData.SampleDataIndex))
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(SampleData.SampleDataIndex);
static const FTextFormat SampleFormat = LOCTEXT("SampleFormat", "{0}: {1}");
TextBuilder.AppendLine(FText::Format(SampleFormat, GetSampleName(BlendSample, SampleData.SampleDataIndex), FText::AsNumber(SampleData.TotalWeight)));
}
}
}
ToolTipText = TextBuilder.ToText();
};
if(bReadOnly)
{
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(PreviewPosition.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(PreviewPosition.Y)));
AddAdvancedPreview();
}
else
{
switch (DragState)
{
// If we are over a sample return its sample value if valid and otherwise show an error message as to why the sample is invalid
case EDragState::None:
{
if (bHighlightPreviewPin)
{
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(PreviewPosition.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(PreviewPosition.Y)));
AddAdvancedPreview();
}
else if (HighlightedSampleIndex != INDEX_NONE && BlendSpace->IsValidBlendSampleIndex(HighlightedSampleIndex))
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(HighlightedSampleIndex);
// Check if the sample is valid
if (BlendSample.bIsValid)
{
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(BlendSample.SampleValue.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(BlendSample.SampleValue.Y)));
}
else
{
ToolTipText = GetSampleErrorMessage(BlendSample);
}
}
else if(TargetPosition.IsSet())
{
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(PreviewPosition.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(PreviewPosition.Y)));
AddAdvancedPreview();
}
break;
}
case EDragState::PreDrag:
{
break;
}
// If we are dragging a sample return the current sample value it is hovered at
case EDragState::DragSample:
{
if (DraggedSampleIndex != INDEX_NONE)
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(DraggedSampleIndex);
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(BlendSample.SampleValue.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(BlendSample.SampleValue.Y)));
}
break;
}
// If we are performing a drag and drop operation return the current sample value it is hovered at
case EDragState::DragDrop:
{
const FVector SampleValue = ScreenPositionToSampleValueWithSnapping(LocalMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown());
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(SampleValue.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(SampleValue.Y)));
break;
}
case EDragState::DragDropOverride:
{
if(HoveredAnimationName.IsEmpty())
{
static const FTextFormat OverrideAnimationFormat = LOCTEXT("InvalidSampleChangingFormat", "Changing sample to {0}");
ToolTipText = FText::Format(OverrideAnimationFormat, DragDropAnimationName);
}
else
{
static const FTextFormat OverrideAnimationFormat = LOCTEXT("ValidSampleChangingFormat", "Changing sample from {0} to {1}");
ToolTipText = FText::Format(OverrideAnimationFormat, HoveredAnimationName, DragDropAnimationName);
}
break;
}
// If the drag and drop operation is invalid return the cached error message as to why it is invalid
case EDragState::InvalidDragDrop:
{
ToolTipText = InvalidDragDropText;
break;
}
// If we are setting the preview value return the current preview sample value
case EDragState::Preview:
{
ToolTipText = FText::Format(ValueFormattingText, ParameterXName, FText::FromString(FString::SanitizeFloat(PreviewPosition.X)), ParameterYName, FText::FromString(FString::SanitizeFloat(PreviewPosition.Y)));
AddAdvancedPreview();
break;
}
default:
check(false);
}
}
}
return ToolTipText;
}
void SBlendSpaceGridWidget::EnableStatusBarMessage(bool bEnable)
{
if(!bReadOnly)
{
if(bEnable)
{
if (!StatusBarMessageHandle.IsValid())
{
if(UStatusBarSubsystem* StatusBarSubsystem = GEditor->GetEditorSubsystem<UStatusBarSubsystem>())
{
StatusBarMessageHandle = StatusBarSubsystem->PushStatusBarMessage(StatusBarName, MakeAttributeLambda([]()
{
return LOCTEXT("StatusBarMssage", "Hold Ctrl to move preview value, and Alt to show weight details. Click and drag sample points to move them, with Shift to snap to the grid.");
}));
}
}
}
else
{
if (StatusBarMessageHandle.IsValid())
{
if(UStatusBarSubsystem* StatusBarSubsystem = GEditor->GetEditorSubsystem<UStatusBarSubsystem>())
{
StatusBarSubsystem->PopStatusBarMessage(StatusBarName, StatusBarMessageHandle);
StatusBarMessageHandle.Reset();
}
}
}
}
}
FText SBlendSpaceGridWidget::GetSampleErrorMessage(const FBlendSample &BlendSample) const
{
const FVector2D GridPosition = SampleValueToScreenPosition(BlendSample.SampleValue);
// Either an invalid animation asset set
if (BlendSample.Animation == nullptr)
{
static const FText NoAnimationErrorText = LOCTEXT("NoAnimationErrorText", "Invalid Animation for Sample");
return NoAnimationErrorText;
}
// Or not aligned on the grid (which means that it does not match one of the cached grid points, == for FVector2D fails to compare though :/)
else if (!CachedGridPoints.FindByPredicate([&](const FVector2D& Other) { return FMath::IsNearlyEqual(GridPosition.X, Other.X) && FMath::IsNearlyEqual(GridPosition.Y, Other.Y);}))
{
static const FText SampleNotAtGridPoint = LOCTEXT("SampleNotAtGridPointErrorText", "Sample is not on a valid Grid Point");
return SampleNotAtGridPoint;
}
static const FText UnknownError = LOCTEXT("UnknownErrorText", "Sample is invalid for an Unknown Reason");
return UnknownError;
}
void SBlendSpaceGridWidget::ShowToolTip()
{
if(HighlightedSampleIndex != INDEX_NONE && ToolTipSampleIndex != HighlightedSampleIndex)
{
ToolTipSampleIndex = HighlightedSampleIndex;
if(OnExtendSampleTooltip.IsBound())
{
ToolTipExtensionContainer->SetContent(OnExtendSampleTooltip.Execute(HighlightedSampleIndex));
}
}
SetToolTip(ToolTip);
}
void SBlendSpaceGridWidget::ResetToolTip()
{
ToolTipSampleIndex = INDEX_NONE;
ToolTipExtensionContainer->SetContent(SNullWidget::NullWidget);
SetToolTip(nullptr);
}
EVisibility SBlendSpaceGridWidget::GetInputBoxVisibility(const int32 ParameterIndex) const
{
bool bVisible = !bReadOnly;
// Only show input boxes when a sample is selected (hide it when one is being dragged since we have the tooltip information as well)
bVisible &= (SelectedSampleIndex != INDEX_NONE && DraggedSampleIndex == INDEX_NONE);
if ( ParameterIndex == 1 )
{
bVisible &= (GridType == EGridType::TwoAxis);
}
return bVisible ? EVisibility::Visible : EVisibility::Collapsed;
}
TOptional<float> SBlendSpaceGridWidget::GetInputBoxValue(const int32 ParameterIndex) const
{
checkf(ParameterIndex < 3, TEXT("Invalid parameter index, suppose to be within FVector array range"));
float ReturnValue = 0.0f;
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
if (SelectedSampleIndex != INDEX_NONE && SelectedSampleIndex < BlendSpace->GetNumberOfBlendSamples())
{
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(SelectedSampleIndex);
ReturnValue = static_cast<float>(BlendSample.SampleValue[ParameterIndex]);
}
}
return ReturnValue;
}
TOptional<float> SBlendSpaceGridWidget::GetInputBoxMinValue(const int32 ParameterIndex) const
{
checkf(ParameterIndex < 3, TEXT("Invalid parameter index, suppose to be within FVector array range"));
return static_cast<float>(SampleValueMin[ParameterIndex]);
}
TOptional<float> SBlendSpaceGridWidget::GetInputBoxMaxValue(const int32 ParameterIndex) const
{
checkf(ParameterIndex < 3, TEXT("Invalid parameter index, suppose to be within FVector array range"));
return static_cast<float>(SampleValueMax[ParameterIndex]);
}
float SBlendSpaceGridWidget::GetInputBoxDelta(const int32 ParameterIndex) const
{
checkf(ParameterIndex < 3, TEXT("Invalid parameter index, suppose to be within FVector array range"));
return static_cast<float>(SampleGridDelta[ParameterIndex]);
}
void SBlendSpaceGridWidget::OnInputBoxValueCommited(const float NewValue, ETextCommit::Type CommitType, const int32 ParameterIndex)
{
OnInputBoxValueChanged(NewValue, ParameterIndex, false);
}
void SBlendSpaceGridWidget::OnInputBoxValueChanged(const float NewValue, const int32 ParameterIndex, bool bIsInteractive)
{
// Ignore any SNumericEntryBox.OnValueChanged broadcasts if sliding has finished and OnInputBoxValueCommited will have been broadcasted already
if (bIsInteractive && !bSliderMovement[ParameterIndex])
{
return;
}
checkf(ParameterIndex < 2, TEXT("Invalid parameter index, suppose to be within FVector array range"));
if (SelectedSampleIndex != INDEX_NONE && BlendSpaceBase.Get() != nullptr)
{
// Retrieve current sample value
const FBlendSample& Sample = BlendSpaceBase.Get()->GetBlendSample(SelectedSampleIndex);
FVector SampleValue = Sample.SampleValue;
// Calculate snapped value
if (bSampleSnapToGrid[ParameterIndex])
{
const double MinOffset = NewValue - SampleValueMin[ParameterIndex];
double GridSteps = MinOffset / SampleGridDelta[ParameterIndex];
int64 FlooredSteps = FMath::FloorToInt(GridSteps);
GridSteps -= FlooredSteps;
FlooredSteps = (GridSteps > .5) ? FlooredSteps + 1 : FlooredSteps;
// Temporary snap this value to closest point on grid (since the spin box delta does not provide the desired functionality)
SampleValue[ParameterIndex] = SampleValueMin[ParameterIndex] + (FlooredSteps * SampleGridDelta[ParameterIndex]);
}
else
{
SampleValue[ParameterIndex] = NewValue;
}
OnSampleMoved.ExecuteIfBound(SelectedSampleIndex, SampleValue, bIsInteractive);
}
}
void SBlendSpaceGridWidget::OnInputSliderBegin(const int32 ParameterIndex)
{
ensure(bSliderMovement[ParameterIndex] == false);
bSliderMovement[ParameterIndex] = true;
}
void SBlendSpaceGridWidget::OnInputSliderEnd(const float NewValue, const int32 ParameterIndex)
{
ensure(bSliderMovement[ParameterIndex] == true);
bSliderMovement[ParameterIndex] = false;
}
EVisibility SBlendSpaceGridWidget::GetSampleToolTipVisibility() const
{
// Show tool tip when the grid is empty
return (!bReadOnly && BlendSpaceBase.Get() != nullptr && BlendSpaceBase.Get()->GetNumberOfBlendSamples() == 0) ? EVisibility::Visible : EVisibility::Collapsed;
}
EVisibility SBlendSpaceGridWidget::GetPreviewToolTipVisibility() const
{
// Only show preview tooltip until the user discovers the functionality
return bReadOnly ? EVisibility::Collapsed : EVisibility::Visible;
}
EVisibility SBlendSpaceGridWidget::GetTriangulationButtonVisibility() const
{
if (bShowSettingsButtons && GridType == EGridType::TwoAxis)
{
if (const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
if (!BlendSpace->bInterpolateUsingGrid)
{
return EVisibility::Visible;
}
}
}
return EVisibility::Collapsed;
}
EVisibility SBlendSpaceGridWidget::GetAnimationNamesButtonVisibility() const
{
return bShowSettingsButtons ? EVisibility::Visible : EVisibility::Collapsed;
}
FReply SBlendSpaceGridWidget::ToggleFittingType()
{
bStretchToFit = !bStretchToFit;
// If toggle to stretching, reset the margin immediately
if (bStretchToFit)
{
GridRatioMargin.Top = GridRatioMargin.Bottom = GridRatioMargin.Left = GridRatioMargin.Right = 0.0f;
}
return FReply::Handled();
}
FReply SBlendSpaceGridWidget::ToggleShowAnimationNames()
{
bShowAnimationNames = !bShowAnimationNames;
return FReply::Handled();
}
void SBlendSpaceGridWidget::UpdateGridRatioMargin(const FVector2D& GeometrySize)
{
if (GridType == EGridType::TwoAxis)
{
// Reset values first
GridRatioMargin.Top = GridRatioMargin.Bottom = GridRatioMargin.Left = GridRatioMargin.Right = 0.0f;
if (GeometrySize.Y > GeometrySize.X)
{
const double Difference = GeometrySize.Y - GeometrySize.X;
GridRatioMargin.Top = GridRatioMargin.Bottom = static_cast<float>(Difference) * 0.5f;
}
else if (GeometrySize.X > GeometrySize.Y)
{
const double Difference = GeometrySize.X - GeometrySize.Y;
GridRatioMargin.Left = GridRatioMargin.Right = static_cast<float>(Difference) * 0.5f;
}
}
}
FText SBlendSpaceGridWidget::GetFittingTypeButtonToolTipText() const
{
static const FText StretchText = LOCTEXT("StretchFittingText", "Stretch Grid to Fit");
static const FText GridRatioText = LOCTEXT("GridRatioFittingText", "Fit Grid to Largest Axis");
return (bStretchToFit) ? GridRatioText : StretchText;
}
EVisibility SBlendSpaceGridWidget::GetFittingButtonVisibility() const
{
return (bShowSettingsButtons && (GridType == EGridType::TwoAxis)) ? EVisibility::Visible : EVisibility::Collapsed;
}
void SBlendSpaceGridWidget::UpdateCachedBlendParameterData()
{
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
const FBlendParameter& BlendParameterX = BlendSpace->GetBlendParameter(0);
const FBlendParameter& BlendParameterY = BlendSpace->GetBlendParameter(1);
SampleValueRange.X = BlendParameterX.Max - BlendParameterX.Min;
SampleValueRange.Y = BlendParameterY.Max - BlendParameterY.Min;
SampleValueMin.X = BlendParameterX.Min;
SampleValueMin.Y = BlendParameterY.Min;
SampleValueMax.X = BlendParameterX.Max;
SampleValueMax.Y = BlendParameterY.Max;
SampleGridDelta = SampleValueRange;
SampleGridDelta.X /= (BlendParameterX.GridNum);
SampleGridDelta.Y /= (BlendParameterY.GridNum);
bSampleSnapToGrid[0] = BlendParameterX.bSnapToGrid;
bSampleSnapToGrid[1] = BlendParameterY.bSnapToGrid;
SampleGridDivisions.X = BlendParameterX.GridNum;
SampleGridDivisions.Y = BlendParameterY.GridNum;
ParameterXName = FText::FromString(BlendParameterX.DisplayName);
ParameterYName = FText::FromString(BlendParameterY.DisplayName);
const TSharedRef< FSlateFontMeasure > FontMeasure = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
MaxVerticalAxisTextWidth = HorizontalAxisMaxTextWidth = MaxHorizontalAxisTextHeight = 0.0f;
FVector2D TextSize = FontMeasure->Measure(ParameterYName, FontInfo);
MaxVerticalAxisTextWidth = FMath::Max(MaxVerticalAxisTextWidth, static_cast<float>(TextSize.X));
TextSize = FontMeasure->Measure(FString::SanitizeFloat(SampleValueMin.Y), FontInfo);
MaxVerticalAxisTextWidth = FMath::Max(MaxVerticalAxisTextWidth, static_cast<float>(TextSize.X));
TextSize = FontMeasure->Measure(FString::SanitizeFloat(SampleValueMax.Y), FontInfo);
MaxVerticalAxisTextWidth = FMath::Max(MaxVerticalAxisTextWidth, static_cast<float>(TextSize.X));
TextSize = FontMeasure->Measure(ParameterXName, FontInfo);
MaxHorizontalAxisTextHeight = FMath::Max(MaxHorizontalAxisTextHeight, static_cast<float>(TextSize.Y));
TextSize = FontMeasure->Measure(FString::SanitizeFloat(SampleValueMin.X), FontInfo);
MaxHorizontalAxisTextHeight = FMath::Max(MaxHorizontalAxisTextHeight, static_cast<float>(TextSize.Y));
TextSize = FontMeasure->Measure(FString::SanitizeFloat(SampleValueMax.X), FontInfo);
MaxHorizontalAxisTextHeight = FMath::Max(MaxHorizontalAxisTextHeight, static_cast<float>(TextSize.Y));
HorizontalAxisMaxTextWidth = static_cast<float>(TextSize.X);
}
}
void SBlendSpaceGridWidget::OnMouseEnter(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
SCompoundWidget::OnMouseEnter(MyGeometry, MouseEvent);
bMouseIsOverGeometry = true;
EnableStatusBarMessage(true);
}
void SBlendSpaceGridWidget::OnMouseLeave(const FPointerEvent& MouseEvent)
{
SCompoundWidget::OnMouseLeave(MouseEvent);
bMouseIsOverGeometry = false;
EnableStatusBarMessage(false);
}
void SBlendSpaceGridWidget::OnFocusLost(const FFocusEvent& InFocusEvent)
{
SCompoundWidget::OnFocusLost(InFocusEvent);
if (DragState == EDragState::DragSample)
{
OnSampleMoved.ExecuteIfBound(DraggedSampleIndex, LastDragPosition, false);
}
HighlightedSampleIndex = DraggedSampleIndex = INDEX_NONE;
DragState = EDragState::None;
bSamplePreviewing = false;
ResetToolTip();
EnableStatusBarMessage(false);
}
bool SBlendSpaceGridWidget::SupportsKeyboardFocus() const
{
return true;
}
void SBlendSpaceGridWidget::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
const int32 PreviousSampleIndex = HighlightedSampleIndex;
HighlightedSampleIndex = INDEX_NONE;
const bool bPreviousHighlightPreviewPin = bHighlightPreviewPin;
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
if(PreviousBlendSpaceBase.Get() != BlendSpace)
{
PreviousBlendSpaceBase = BlendSpace;
InvalidateCachedData();
}
GridType = BlendSpace->IsA<UBlendSpace1D>() ? EGridType::SingleAxis : EGridType::TwoAxis;
BlendParametersToDraw = (GridType == EGridType::SingleAxis) ? 1 : 2;
if(!bReadOnly)
{
if (DragState == EDragState::None)
{
// Check if we are highlighting preview pin
float Distance;
bHighlightPreviewPin = IsSampleValueWithinMouseRange(PreviewPosition, Distance);
if (bHighlightPreviewPin)
{
if (bHighlightPreviewPin != bPreviousHighlightPreviewPin)
{
ShowToolTip();
}
}
else if (bPreviousHighlightPreviewPin != bHighlightPreviewPin)
{
ResetToolTip();
}
// Determine highlighted sample
HighlightedSampleIndex = GetClosestSamplePointIndexToMouse();
if (!bHighlightPreviewPin)
{
// If we started selecting or selected a different sample make sure we show/hide the tooltip
if (PreviousSampleIndex != HighlightedSampleIndex)
{
if (HighlightedSampleIndex != INDEX_NONE)
{
ShowToolTip();
}
else
{
ResetToolTip();
}
}
}
}
else if (DragState == EDragState::DragSample)
{
// If we are dragging a sample, find out whether or not it has actually moved to a
// different grid position since the last tick and update the blend space accordingly
FVector SampleValue = ScreenPositionToSampleValueWithSnapping(LocalMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown());
// Only allow dragging on each axis if not locked
const FBlendSample& BlendSample = BlendSpace->GetBlendSample(DraggedSampleIndex);
if (SampleValue != LastDragPosition)
{
LastDragPosition = SampleValue;
OnSampleMoved.ExecuteIfBound(DraggedSampleIndex, SampleValue, true);
}
}
else if (DragState == EDragState::DragDrop || DragState == EDragState::InvalidDragDrop || DragState == EDragState::DragDropOverride)
{
// Validate that the sample is not overlapping with a current sample when doing a
// drag/drop operation and that we are dropping a valid animation for the blend
// space (type)
const FVector DropSampleValue = ScreenPositionToSampleValueWithSnapping(LocalMousePosition, FSlateApplication::Get().GetModifierKeys().IsShiftDown());
const bool bValidPosition = BlendSpace->IsSampleWithinBounds(DropSampleValue);
const bool bExistingSample = BlendSpace->IsTooCloseToExistingSamplePoint(DropSampleValue, INDEX_NONE);
const bool bValidSequence = ValidateAnimationSequence(DragDropAnimationSequence, InvalidDragDropText);
if (!bValidSequence)
{
DragState = EDragState::InvalidDragDrop;
}
else if (!bValidPosition)
{
InvalidDragDropText = InvalidSamplePositionDragDropText;
DragState = EDragState::InvalidDragDrop;
}
else if (bExistingSample)
{
const TArray<FBlendSample>& Samples = BlendSpace->GetBlendSamples();
for (int32 SampleIndex = 0; SampleIndex < Samples.Num(); ++SampleIndex)
{
const FBlendSample& Sample = Samples[SampleIndex];
if (Sample.SampleValue == DropSampleValue)
{
HoveredAnimationName = Sample.Animation ? FText::FromString(Sample.Animation->GetName()) : FText::GetEmpty();
break;
}
}
DragState = EDragState::DragDropOverride;
}
else if (bValidPosition && bValidSequence && !bExistingSample)
{
DragState = EDragState::DragDrop;
}
}
}
// Check if we should update the preview sample value
if (bSamplePreviewing)
{
// Clamping happens later
LastPreviewingMousePosition.X = LocalMousePosition.X;
LastPreviewingMousePosition.Y = LocalMousePosition.Y;
FModifierKeysState ModifierKeyState = FSlateApplication::Get().GetModifierKeys();
bool bIsManualPreviewing = !bReadOnly && IsHovered() && bMouseIsOverGeometry && ModifierKeyState.IsControlDown();
if (TargetPosition.IsSet() && !bIsManualPreviewing)
{
PreviewPosition = TargetPosition.Get();
if (bReadOnly)
{
// Happens when we are showing in the graph - don't want to render outside the valid region
PreviewPosition = BlendSpace->GetClampedAndWrappedBlendInput(PreviewPosition);
}
}
else
{
PreviewPosition = ScreenPositionToSampleValue(LastPreviewingMousePosition, true);
}
if (FilteredPosition.IsSet())
{
PreviewFilteredPosition = BlendSpace->GetClampedAndWrappedBlendInput(FilteredPosition.Get());
}
// Retrieve and cache weighted samples
PreviewedSamples.Empty(4);
BlendSpace->GetSamplesFromBlendInput(PreviewPosition, PreviewedSamples, CachedTriangulationIndex, false);
}
}
// Refresh cache blendspace/grid data if needed
if (bRefreshCachedData)
{
UpdateCachedBlendParameterData();
GridMargin = bShowAxisLabels ? FMargin(MaxVerticalAxisTextWidth + (TextMargin * 2.0f), TextMargin, (HorizontalAxisMaxTextWidth *.5f) + TextMargin, MaxHorizontalAxisTextHeight + (TextMargin * 2.0f)) :
FMargin(TextMargin, TextMargin, TextMargin, TextMargin);
bRefreshCachedData = false;
}
// Always need to update the rectangle and grid points according to the geometry (this can differ per tick)
CachedGridRectangle = GetGridRectangleFromGeometry(AllottedGeometry);
CalculateGridPoints();
}
const FVector SBlendSpaceGridWidget::GetPreviewPosition() const
{
return PreviewPosition;
}
void SBlendSpaceGridWidget::SetPreviewingState(const FVector& InPosition, const FVector& InFilteredPosition)
{
if (const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
PreviewFilteredPosition = BlendSpace->GetClampedAndWrappedBlendInput(InFilteredPosition);
}
else
{
PreviewFilteredPosition = InFilteredPosition;
}
PreviewPosition = InPosition;
}
void SBlendSpaceGridWidget::InvalidateCachedData()
{
bRefreshCachedData = true;
}
void SBlendSpaceGridWidget::InvalidateState()
{
if (HighlightedSampleIndex != INDEX_NONE)
{
ResetToolTip();
}
if (DragState != EDragState::None)
{
DragState = EDragState::None;
}
SelectedSampleIndex = (BlendSpaceBase.Get() != nullptr && BlendSpaceBase.Get()->IsValidBlendSampleIndex(SelectedSampleIndex)) ? SelectedSampleIndex : INDEX_NONE;
HighlightedSampleIndex = DraggedSampleIndex = INDEX_NONE;
}
const bool SBlendSpaceGridWidget::IsValidDragDropOperation(const FDragDropEvent& DragDropEvent, FText& InvalidOperationText)
{
bool bResult = false;
TSharedPtr<FAssetDragDropOp> DragDropOperation = DragDropEvent.GetOperationAs<FAssetDragDropOp>();
if (DragDropOperation.IsValid())
{
// Check whether or not this animation is compatible with the blend space
DragDropAnimationSequence = FAssetData::GetFirstAsset<UAnimSequence>(DragDropOperation->GetAssets());
if (DragDropAnimationSequence)
{
bResult = ValidateAnimationSequence(DragDropAnimationSequence, InvalidOperationText);
}
else
{
// If is isn't an animation set error message
bResult = false;
InvalidOperationText = FText::FromString("Invalid Asset Type");
}
}
if (!bResult)
{
DragDropOperation->SetToolTip(InvalidOperationText, DragDropOperation->GetIcon());
}
else
{
DragDropAnimationName = FText::FromString(DragDropAnimationSequence->GetName());
}
return bResult;
}
bool SBlendSpaceGridWidget::ValidateAnimationSequence(const UAnimSequence* AnimationSequence, FText& InvalidOperationText) const
{
if (AnimationSequence != nullptr)
{
if(const UBlendSpace* BlendSpace = BlendSpaceBase.Get())
{
if(BlendSpace->IsAsset())
{
// If there are any existing blend samples check whether or not the the animation should be additive and if so if the additive matches the existing samples
if ( BlendSpace->GetNumberOfBlendSamples() > 0)
{
const bool bIsAdditive = BlendSpace->ShouldAnimationBeAdditive();
if (AnimationSequence->IsValidAdditive() != bIsAdditive)
{
InvalidOperationText = FText::FromString(bIsAdditive ? "Animation should be additive" : "Animation should be non-additive");
return false;
}
// If it is the supported additive type, but does not match existing samples
if (!BlendSpace->DoesAnimationMatchExistingSamples(AnimationSequence))
{
InvalidOperationText = FText::FromString("Additive Animation Type does not match existing Samples");
return false;
}
}
// Check if the supplied animation is of a different additive animation type
if (!BlendSpace->IsAnimationCompatible(AnimationSequence))
{
InvalidOperationText = FText::FromString("Invalid Additive Animation Type");
return false;
}
// Check if the supplied animation is compatible with the skeleton
if (!BlendSpace->IsAnimationCompatibleWithSkeleton(AnimationSequence))
{
InvalidOperationText = FText::FromString("Animation is incompatible with the skeleton");
return false;
}
}
}
}
return AnimationSequence != nullptr;
}
const bool SBlendSpaceGridWidget::IsPreviewing() const
{
FModifierKeysState ModifierKeyState = FSlateApplication::Get().GetModifierKeys();
bool bIsManualPreviewing = !bReadOnly && IsHovered() && bMouseIsOverGeometry && ModifierKeyState.IsControlDown();
return (bSamplePreviewing && !TargetPosition.IsSet()) || (TargetPosition.IsSet() && bIsManualPreviewing);
}
void SBlendSpaceGridWidget::BindCommands()
{
// This should not be called twice on the same instance
check(!UICommandList.IsValid());
UICommandList = MakeShared<FUICommandList>();
UICommandList->MapAction(
FGenericCommands::Get().Cut,
FExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::OnBlendSampleCut),
FCanExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::CanBlendSampleCutCopy)
);
UICommandList->MapAction(
FGenericCommands::Get().Copy,
FExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::OnBlendSampleCopy),
FCanExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::CanBlendSampleCutCopy)
);
UICommandList->MapAction(
FGenericCommands::Get().Paste,
FExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::OnBlendSamplePaste),
FCanExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::CanBlendSamplePaste)
);
UICommandList->MapAction(
FGenericCommands::Get().Delete,
FExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::OnBlendSampleDelete),
FCanExecuteAction::CreateSP(this, &SBlendSpaceGridWidget::CanBlendSampleDelete)
);
}
bool SBlendSpaceGridWidget::CanBlendSampleCutCopy()
{
return BlendSpaceBase.Get()->IsValidBlendSampleIndex(SelectedSampleIndex);
}
bool SBlendSpaceGridWidget::CanBlendSamplePaste()
{
FString PastedText;
FPlatformApplicationMisc::ClipboardPaste(PastedText);
return PastedText.StartsWith(BlendSpaceBase.Get()->IsAsset() ? BlendSampleClipboardHeaderAsset : BlendSampleClipboardHeaderGraph);
}
bool SBlendSpaceGridWidget::CanBlendSampleDelete()
{
return BlendSpaceBase.Get()->IsValidBlendSampleIndex(SelectedSampleIndex);
}
void SBlendSpaceGridWidget::OnBlendSampleDelete()
{
if (SelectedSampleIndex != INDEX_NONE)
{
OnSampleRemoved.ExecuteIfBound(SelectedSampleIndex);
if (SelectedSampleIndex == HighlightedSampleIndex)
{
HighlightedSampleIndex = INDEX_NONE;
ResetToolTip();
}
SelectedSampleIndex = INDEX_NONE;
}
}
void SBlendSpaceGridWidget::OnBlendSampleCut()
{
if (BlendSpaceBase.Get()->IsValidBlendSampleIndex(SelectedSampleIndex))
{
OnBlendSampleCopy();
OnSampleRemoved.ExecuteIfBound(SelectedSampleIndex);
}
}
void SBlendSpaceGridWidget::OnBlendSampleCopy()
{
typedef TJsonWriter<TCHAR, TPrettyJsonPrintPolicy<TCHAR>> FStringWriter;
typedef TJsonWriterFactory<TCHAR, TPrettyJsonPrintPolicy<TCHAR>> FStringWriterFactory;
TSharedRef<FJsonObject> RootJsonObject = MakeShareable(new FJsonObject());
const UBlendSpace* BlendSpace = BlendSpaceBase.Get();
if (!BlendSpace->IsValidBlendSampleIndex(SelectedSampleIndex))
{
return;
}
if (BlendSpace->IsAsset())
{
FBlendSample SampleToCopy = BlendSpace->GetBlendSample(SelectedSampleIndex);
FJsonObjectConverter::UStructToJsonObject(FBlendSample::StaticStruct(), &SampleToCopy, RootJsonObject, 0 /* CheckFlags */, 0 /* SkipFlags */);
}
else
{
UBlendSpaceGraph* BlendSpaceGraph = CastChecked<UBlendSpaceGraph>(BlendSpace->GetOuter());
UAnimGraphNode_BlendSpaceGraphBase* BlendSpaceNode = CastChecked<UAnimGraphNode_BlendSpaceGraphBase>(BlendSpaceGraph->GetOuter());
UAnimationBlendSpaceSampleGraph* GraphSampleToCopy = CastChecked<UAnimationBlendSpaceSampleGraph>(BlendSpaceNode->GetGraphs()[SelectedSampleIndex]);
TSet<UObject*> NodesSet;
for (TObjectPtr<UEdGraphNode>& Node : GraphSampleToCopy->Nodes)
{
NodesSet.Add(Node);
}
FStringOutputDevice NodesString;
FEdGraphUtilities::ExportNodesToText(NodesSet, NodesString);
RootJsonObject->SetField(TEXT("Nodes"), MakeShared<FJsonValueString>(NodesString));
// Output Animation Pose node is not pasted as it already exists in the pasted graph
// Take note of the node that connects to it to reconstruct the link (if exists) on paste
UEdGraphPin* ResultNodePosePin = GraphSampleToCopy->ResultNode->FindPinChecked(TEXT("Result"), EEdGraphPinDirection::EGPD_Input);
if (ResultNodePosePin->LinkedTo.Num() == 1)
{
UEdGraphPin* ConnectedNodePosePin = ResultNodePosePin->LinkedTo[0];
UEdGraphNode* OwningNode = ConnectedNodePosePin->GetOwningNode();
RootJsonObject->SetField(TEXT("NodeConnectedToResult"), MakeShared<FJsonValueString>(OwningNode->NodeGuid.ToString()));
}
}
FString SerializedStr;
TSharedRef<FStringWriter> Writer = FStringWriterFactory::Create(&SerializedStr);
FJsonSerializer::Serialize(RootJsonObject, Writer);
SerializedStr = *FString::Printf(TEXT("%s%s"), BlendSpace->IsAsset() ? *BlendSampleClipboardHeaderAsset : *BlendSampleClipboardHeaderGraph, *SerializedStr);
FPlatformApplicationMisc::ClipboardCopy(*SerializedStr);
}
void SBlendSpaceGridWidget::OnBlendSamplePaste()
{
FString PastedText;
FPlatformApplicationMisc::ClipboardPaste(PastedText);
check(OnSampleAdded.IsBound());
const FVector SampleValue = ScreenPositionToSampleValue(LocalMousePosition, true); // Paste the sample at the cursor's location
int32 NewSampleIndex = INDEX_NONE;
if (BlendSpaceBase.Get()->IsAsset())
{
check(PastedText.StartsWith(BlendSampleClipboardHeaderAsset));
PastedText.RightChopInline(BlendSampleClipboardHeaderAsset.Len());
TSharedPtr<FJsonObject> RootJsonObject;
TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(PastedText);
if (!FJsonSerializer::Deserialize(Reader, RootJsonObject))
{
return;
}
FBlendSample SampleToPaste;
if (FJsonObjectConverter::JsonObjectToUStruct(RootJsonObject.ToSharedRef(), FBlendSample::StaticStruct(), &SampleToPaste, 0 /* CheckFlags */, 0 /* SkipFlags */))
{
const FScopedTransaction Transaction(LOCTEXT("PasteBlendSpaceSample", "Paste Blend Space Sample"));
NewSampleIndex = OnSampleAdded.Execute(SampleToPaste.Animation, SampleValue, false);
}
}
else
{
check(PastedText.StartsWith(BlendSampleClipboardHeaderGraph));
PastedText.RightChopInline(BlendSampleClipboardHeaderGraph.Len());
TSharedPtr<FJsonObject> RootJsonObject;
TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(PastedText);
if (!FJsonSerializer::Deserialize(Reader, RootJsonObject))
{
return;
}
check(RootJsonObject->HasField(TEXT("Nodes")));
const FScopedTransaction Transaction(LOCTEXT("PasteBlendSpaceSample", "Paste Blend Space Sample"));
UBlendSpaceGraph* BlendSpaceGraph = CastChecked<UBlendSpaceGraph>(BlendSpaceBase.Get()->GetOuter());
UAnimGraphNode_BlendSpaceGraphBase* BlendSpaceNode = CastChecked<UAnimGraphNode_BlendSpaceGraphBase>(BlendSpaceGraph->GetOuter());
UAnimationBlendSpaceSampleGraph* DestinationGraph = nullptr;
NewSampleIndex = OnSampleAdded.Execute(nullptr, SampleValue, false);
DestinationGraph = CastChecked<UAnimationBlendSpaceSampleGraph>(BlendSpaceNode->GetGraphs()[NewSampleIndex]);
FString NodesSetString = RootJsonObject->GetStringField(TEXT("Nodes"));
TSet<UEdGraphNode*> ImportedNodes;
FEdGraphUtilities::ImportNodesFromText(DestinationGraph, NodesSetString, ImportedNodes);
// Reconstruct link to output, if exists
if (RootJsonObject->HasField(TEXT("NodeConnectedToResult")))
{
FString NodeConnectedToResult = RootJsonObject->GetStringField(TEXT("NodeConnectedToResult"));
FGuid ResultNodeGuid(NodeConnectedToResult);
UEdGraphPin* ResultNodePosePin = DestinationGraph->ResultNode->FindPinChecked(TEXT("Result"), EEdGraphPinDirection::EGPD_Input);
check(ResultNodePosePin->LinkedTo.Num() == 0);
for (UEdGraphNode* Node : ImportedNodes)
{
if (Node->NodeGuid == ResultNodeGuid)
{
UEdGraphPin* PosePin = Node->FindPinChecked(TEXT("Pose"), EEdGraphPinDirection::EGPD_Output);
check(PosePin->LinkedTo.Num() == 0);
PosePin->MakeLinkTo(ResultNodePosePin);
break;
}
}
}
for (UEdGraphNode* ImportedNode : ImportedNodes)
{
ImportedNode->CreateNewGuid();
}
}
SelectedSampleIndex = NewSampleIndex;
HighlightedSampleIndex = INDEX_NONE;
}
#undef LOCTEXT_NAMESPACE // "SAnimationBlendSpaceGridWidget"
Reference in New Issue View Git Blame Copy Permalink