static FORCEINLINE float GetScaleFactor(const FGeometry& Geometry)
{
const float DesiredWidth = 1024.0f;
float UndoDPIScaling = 1.0f / Geometry.Scale;
return (Geometry.GetDrawSize().GetMax() / DesiredWidth) * UndoDPIScaling;
}
void FSceneViewport::OnDrawViewport( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled )
{
// Switch to the viewport clients world before resizing
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
/** Check to see if the viewport should be resized */
FIntPoint DrawSize = FIntPoint( FMath::RoundToInt( AllottedGeometry.GetDrawSize().X ), FMath::RoundToInt( AllottedGeometry.GetDrawSize().Y ) );
if( GetSizeXY() != DrawSize )
{
TSharedPtr<SWindow> Window = FSlateApplication::Get().FindWidgetWindow( ViewportWidget.Pin().ToSharedRef() );
check(Window.IsValid());
ResizeViewport(FMath::Max(0, DrawSize.X), FMath::Max(0, DrawSize.Y), Window->GetWindowMode(), 0, 0);
}
// Cannot pass negative canvas positions
float CanvasMinX = FMath::Max(0.0f, AllottedGeometry.AbsolutePosition.X);
float CanvasMinY = FMath::Max(0.0f, AllottedGeometry.AbsolutePosition.Y);
FIntRect CanvasRect(
FMath::RoundToInt( CanvasMinX ),
FMath::RoundToInt( CanvasMinY ),
FMath::RoundToInt( CanvasMinX + AllottedGeometry.Size.X * AllottedGeometry.Scale ),
FMath::RoundToInt( CanvasMinY + AllottedGeometry.Size.Y * AllottedGeometry.Scale ) );
DebugCanvasDrawer->BeginRenderingCanvas( CanvasRect );
// Draw above everything else
uint32 MaxLayer = MAX_uint32;
FSlateDrawElement::MakeCustom( OutDrawElements, MAX_uint32, DebugCanvasDrawer );
}
FVector2D FGeometryHelper::VerticalMiddleRightOf(const FGeometry& SomeGeometry)
{
const FVector2D GeometryDrawSize = SomeGeometry.GetDrawSize();
return FVector2D(
SomeGeometry.AbsolutePosition.X + GeometryDrawSize.X,
SomeGeometry.AbsolutePosition.Y + GeometryDrawSize.Y/2 );
}
FGeometry SSection::GetKeyAreaGeometry( const struct FKeyAreaElement& KeyArea, const FGeometry& SectionGeometry ) const
{
// Get the height of the key area node. If the key area is top level then it is part of the section (and the same height ) and doesn't take up extra space
float KeyAreaHeight = KeyArea.KeyAreaNode.IsTopLevel() ? SectionGeometry.GetDrawSize().Y : KeyArea.KeyAreaNode.GetNodeHeight();
// Compute the geometry for the key area
return SectionGeometry.MakeChild( FVector2D( 0, KeyArea.HeightOffset ), FVector2D( SectionGeometry.Size.X, KeyAreaHeight ) );
}
void FGeometryHelper::ConvertToPoints(const FGeometry& Geom, TArray<FVector2D>& Points)
{
const FVector2D Size = Geom.GetDrawSize();
const FVector2D Location = Geom.AbsolutePosition;
int32 Index = Points.AddUninitialized(4);
Points[Index++] = Location;
Points[Index++] = Location + FVector2D(0.0f, Size.Y);
Points[Index++] = Location + FVector2D(Size.X, Size.Y);
Points[Index++] = Location + FVector2D(Size.X, 0.0f);
}
void SMenuAnchor::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
SPanel::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
TSharedPtr<SWindow> PopupWindow = PopupWindowPtr.Pin();
if ( PopupWindow.IsValid() && Method == CreateNewWindow )
{
// Figure out where our attached pop-up window should be placed.
const FVector2D PopupContentDesiredSize = PopupWindow->GetContent()->GetDesiredSize();
FGeometry PopupGeometry = ComputeMenuPlacement( AllottedGeometry, PopupContentDesiredSize, Placement.Get( ) );
const FVector2D NewPosition = PopupGeometry.AbsolutePosition;
const FVector2D NewSize = PopupGeometry.GetDrawSize( );
const FSlateRect NewShape = FSlateRect( NewPosition.X, NewPosition.Y, NewPosition.X + NewSize.X, NewPosition.Y + NewSize.Y );
// We made a window for showing the popup.
// Update the window's position!
if( PopupWindow->IsMorphing() )
{
if( NewShape != PopupWindow->GetMorphTargetShape() )
{
// Update the target shape
PopupWindow->UpdateMorphTargetShape( NewShape );
// Set size immediately if not morphing size
if(!PopupWindow->IsMorphingSize())
{
PopupWindow->ReshapeWindow( PopupWindow->GetPositionInScreen(), NewSize );
}
}
}
else
{
const FVector2D WindowPosition = PopupWindow->GetPositionInScreen();
const FVector2D WindowSize = PopupWindow->GetSizeInScreen();
if ( NewPosition != WindowPosition || NewSize != WindowSize )
{
#if PLATFORM_LINUX
// @FIXME: for some reason, popups reshaped here do not trigger OnWindowMoved() callback,
// so we manually set cached position to where we expect it to be. Note the order of operations - (before Reshape) -
// still giving the callback a chance to change it.
// This needs to be investigated (tracked as TTP #347674).
PopupWindow->SetCachedScreenPosition( NewPosition );
#endif // PLATFORM_LINUX
PopupWindow->ReshapeWindow( NewShape );
}
}
}
/** The tick is ending, so the window was not dismissed this tick. */
bDismissedThisTick = false;
}
FReply SGraphPin::OnPinNameMouseDown( const FGeometry& SenderGeometry, const FPointerEvent& MouseEvent )
{
const float LocalX = SenderGeometry.AbsoluteToLocal( MouseEvent.GetScreenSpacePosition() ).X;
if ((GetDirection() == EGPD_Input) || (LocalX > SenderGeometry.GetDrawSize().X * 0.5f))
{
// Right half of the output pin or all of the input pin, treat it like a connection attempt
return OnPinMouseDown(SenderGeometry, MouseEvent);
}
else
{
return FReply::Unhandled();
}
}
void SSequencerSectionAreaView::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
int32 MaxRowIndex = 0;
for( int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex )
{
const TSharedRef<SSection>& Widget = Children[WidgetIndex];
TSharedPtr<ISequencerSection> SectionInterface = Widget->GetSectionInterface();
MaxRowIndex = FMath::Max(MaxRowIndex, SectionInterface->GetSectionObject()->GetRowIndex());
}
int32 MaxTracks = MaxRowIndex + 1;
float SectionHeight = GetSectionAreaHeight();
FTimeToPixel TimeToPixelConverter = GetTimeToPixel( AllottedGeometry );
for( int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex )
{
const TSharedRef<SSection>& Widget = Children[WidgetIndex];
TSharedPtr<ISequencerSection> SectionInterface = Widget->GetSectionInterface();
int32 RowIndex = SectionInterface->GetSectionObject()->GetRowIndex();
FGeometry SectionGeometry = SequencerSectionUtils::GetSectionGeometry( AllottedGeometry, RowIndex, MaxTracks, SectionHeight, SectionInterface, TimeToPixelConverter );
EVisibility Visibility = Widget->GetVisibility();
if( ArrangedChildren.Accepts( Visibility ) )
{
Widget->CacheParentGeometry(AllottedGeometry);
ArrangedChildren.AddWidget(
Visibility,
AllottedGeometry.MakeChild( Widget, SectionGeometry.Position, SectionGeometry.GetDrawSize() )
);
}
}
}
float FKeyAreaLayoutElement::GetHeight(const FGeometry& InParentGeometry) const
{
return Height.IsSet() ? Height.GetValue() : InParentGeometry.GetDrawSize().Y;
}
void SAnimationOutlinerView::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const float Padding = SequencerLayoutConstants::NodePadding;
const float IndentAmount = SequencerLayoutConstants::IndentAmount;
float CurrentHeight = 0;
for (int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex)
{
const TSharedRef<SAnimationOutlinerTreeNode>& Widget = Children[WidgetIndex];
EVisibility Visibility = Widget->GetVisibility();
if( ArrangedChildren.Accepts( Visibility ) )
{
const TSharedPtr<const FSequencerDisplayNode>& DisplayNode = Widget->GetDisplayNode();
// How large to make this node
float HeightIncrement = DisplayNode->GetNodeHeight();
// How far to indent the widget
float WidgetIndentOffset = IndentAmount*DisplayNode->GetTreeLevel();
// Place the widget at the current height, at the nodes desired size
ArrangedChildren.AddWidget(
Visibility,
AllottedGeometry.MakeChild( Widget, FVector2D( WidgetIndentOffset, CurrentHeight ), FVector2D( AllottedGeometry.GetDrawSize().X-WidgetIndentOffset, HeightIncrement ) )
);
// Compute the start height for the next widget
CurrentHeight += HeightIncrement+Padding;
}
}
}
void SMultiBoxWidget::UpdateDropAreaPreviewBlock( TSharedRef<const FMultiBlock> MultiBlock, TSharedPtr<FUICommandDragDropOp> DragDropContent, const FGeometry& DragAreaGeometry, const FVector2D& DragPos )
{
TSharedPtr<const FUICommandInfo> UICommand = DragDropContent->UICommand;
FName OriginMultiBox = DragDropContent->OriginMultiBox;
FVector2D LocalDragPos = DragAreaGeometry.AbsoluteToLocal( DragPos );
FVector2D DrawSize = DragAreaGeometry.GetDrawSize();
bool bAddedNewBlock = false;
bool bValidCommand = true;
if( DragPreview.UICommand != UICommand )
{
TSharedPtr<const FMultiBlock> ExistingBlock = MultiBox->FindBlockFromCommand( UICommand );
// Check that the command does not already exist and that we can create it or that we are dragging an exisiting block in this box
if( !ExistingBlock.IsValid() || ( ExistingBlock.IsValid() && OriginMultiBox == MultiBox->GetCustomizationName() ) )
{
TSharedPtr<const FMultiBlock> NewBlock = ExistingBlock;
if( !ExistingBlock.IsValid() )
{
NewBlock = MultiBox->MakeMultiBlockFromCommand( UICommand, true );
}
if( NewBlock.IsValid() )
{
DragPreview.Reset();
DragPreview.UICommand = UICommand;
DragPreview.PreviewBlock =
MakeShareable(
new FDropPreviewBlock(
NewBlock.ToSharedRef(),
NewBlock->MakeWidget( SharedThis(this), EMultiBlockLocation::None, NewBlock->HasIcon() ) )
);
bAddedNewBlock = true;
}
}
else
{
// this command cannot be dropped here
bValidCommand = false;
}
}
if( bValidCommand )
{
// determine whether or not to insert before or after
bool bInsertBefore = false;
if( MultiBox->GetType() == EMultiBoxType::ToolBar )
{
DragPreview.InsertOrientation = EOrientation::Orient_Horizontal;
if( LocalDragPos.X < DrawSize.X / 2 )
{
// Insert before horizontally
bInsertBefore = true;
}
else
{
// Insert after horizontally
bInsertBefore = false;
}
}
else
{
DragPreview.InsertOrientation = EOrientation::Orient_Vertical;
if( LocalDragPos.Y < DrawSize.Y / 2 )
{
// Insert before vertically
bInsertBefore = true;
}
else
{
// Insert after vertically
bInsertBefore = false;
}
}
int32 CurrentIndex = DragPreview.InsertIndex;
DragPreview.InsertIndex = INDEX_NONE;
// Find the index of the multiblock being dragged over. This is where we will insert the new block
if( DragPreview.PreviewBlock.IsValid() )
{
const TArray< TSharedRef< const FMultiBlock > >& Blocks = MultiBox->GetBlocks();
for (int32 BlockIdx = 0; BlockIdx < Blocks.Num(); ++BlockIdx)
{
TSharedRef<const FMultiBlock> Block = Blocks[BlockIdx];
if( Block == MultiBlock )
{
if( bInsertBefore)
{
DragPreview.InsertIndex = BlockIdx;
}
else
{
DragPreview.InsertIndex = FMath::Min(Blocks.Num()-1, BlockIdx+1);
}
break;
}
}
}
if( CurrentIndex != DragPreview.InsertIndex && DragPreview.InsertIndex != INDEX_NONE )
{
BuildMultiBoxWidget();
}
}
}
int32 STrack::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
int32 CustomLayerId = LayerId + 1;
FPaintGeometry MyGeometry = AllottedGeometry.ToPaintGeometry();
// Background
FSlateDrawElement::MakeBox(
OutDrawElements,
CustomLayerId++,
MyGeometry,
FEditorStyle::GetBrush(TEXT( "Persona.NotifyEditor.NotifyTrackBackground" )),
MyClippingRect,
ESlateDrawEffect::None,
TrackColor.Get()
);
// Draw Scrub Position
if ( ScrubPosition.Get() >= 0.f )
{
float XPos = DataToLocalX(ScrubPosition.Get(), AllottedGeometry);
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(XPos, 0.f));
LinePoints.Add(FVector2D(XPos, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
CustomLayerId++,
MyGeometry,
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor(1, 0, 0)
);
}
// Draggable Bars
for ( int32 I=0; DraggableBars.IsBound() && I < DraggableBars.Get().Num(); I++ )
{
// Draw lines
float XPos = DataToLocalX(DraggableBars.Get()[I], AllottedGeometry);
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(XPos, 0.f));
LinePoints.Add(FVector2D(XPos, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
CustomLayerId,
MyGeometry,
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor(0.0f, 1.0f, 0.0f, 1.0f)
);
// Draw Labels
if (DraggableBarLabels.IsBound() && DraggableBarLabels.Get().IsValidIndex(I))
{
//float EndPos = (DraggableBarIndex.Get().IsValidIndex(I+1) ? DraggableBarIndex.Get()(I+1)
FPaintGeometry TextGeometry = AllottedGeometry.ToPaintGeometry( FVector2D(XPos + 5.f, 5.f), AllottedGeometry.GetDrawSize() );
FSlateDrawElement::MakeText(
OutDrawElements,
CustomLayerId,
TextGeometry,
DraggableBarLabels.Get()[I],
Font,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black
);
}
}
// Ghost snap position
float SnapPos = 0.f;
if ( GetDraggableBarSnapPosition(AllottedGeometry, SnapPos) )
{
SnapPos = DataToLocalX(SnapPos, AllottedGeometry);
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(SnapPos, 0.f));
LinePoints.Add(FVector2D(SnapPos, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
CustomLayerId,
MyGeometry,
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor(0.5f, 0.0f, 0.0f, 0.5f)
);
}
CustomLayerId++;
// draw line for every 1/4 length
if ( TrackMaxValue.Get() > 0.f && TrackNumDiscreteValues.Get() > 0 )
{
int32 Divider = SScrubWidget::GetDivider( ViewInputMin.Get(), ViewInputMax.Get(), AllottedGeometry.Size, TrackMaxValue.Get(), TrackNumDiscreteValues.Get());
const float TimePerValue = TrackMaxValue.Get()/static_cast<float>(TrackNumDiscreteValues.Get());
for (int I=1; I<TrackNumDiscreteValues.Get(); ++I)
{
if ( I % Divider == 0 )
{
float XPos = DataToLocalX(TimePerValue*I, AllottedGeometry);
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(XPos, 0.f));
LinePoints.Add(FVector2D(XPos, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
CustomLayerId,
MyGeometry,
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black
);
}
}
++CustomLayerId;
}
return SPanel::OnPaint( AllottedGeometry, MyClippingRect, OutDrawElements, CustomLayerId, InWidgetStyle, bParentEnabled );
}
FSelectedKey SSection::GetKeyUnderMouse( const FVector2D& MousePosition, const FGeometry& AllottedGeometry ) const
{
UMovieSceneSection& Section = *SectionInterface->GetSectionObject();
// Search every key area until we find the one under the mouse
for( int32 KeyAreaIndex = 0; KeyAreaIndex < KeyAreas.Num(); ++KeyAreaIndex )
{
const FKeyAreaElement& Element = KeyAreas[KeyAreaIndex];
TSharedRef<IKeyArea> KeyArea = Element.KeyAreaNode.GetKeyArea( SectionIndex );
// Compute the current key area geometry
FGeometry KeyAreaGeometryPadded = GetKeyAreaGeometry( Element, AllottedGeometry );
// Is the key area under the mouse
if( KeyAreaGeometryPadded.IsUnderLocation( MousePosition ) )
{
FGeometry SectionGeometry = AllottedGeometry.MakeChild(FVector2D(SequencerSectionConstants::SectionGripSize, 0), AllottedGeometry.GetDrawSize() - FVector2D(SequencerSectionConstants::SectionGripSize*2, 0.0f));
FGeometry KeyAreaGeometry = GetKeyAreaGeometry( Element, SectionGeometry );
FVector2D LocalSpaceMousePosition = KeyAreaGeometry.AbsoluteToLocal( MousePosition );
FTimeToPixel TimeToPixelConverter = Section.IsInfinite() ?
FTimeToPixel( ParentGeometry, GetSequencer().GetViewRange()) :
FTimeToPixel( KeyAreaGeometry, TRange<float>( Section.GetStartTime(), Section.GetEndTime() ) );
// Check each key until we find one under the mouse (if any)
TArray<FKeyHandle> KeyHandles = KeyArea->GetUnsortedKeyHandles();
for( int32 KeyIndex = 0; KeyIndex < KeyHandles.Num(); ++KeyIndex )
{
FKeyHandle KeyHandle = KeyHandles[KeyIndex];
float KeyPosition = TimeToPixelConverter.TimeToPixel( KeyArea->GetKeyTime(KeyHandle) );
FGeometry KeyGeometry = KeyAreaGeometry.MakeChild(
FVector2D( KeyPosition - FMath::TruncToFloat(SequencerSectionConstants::KeySize.X/2.0f), ((KeyAreaGeometry.Size.Y*.5f)-(SequencerSectionConstants::KeySize.Y*.5f)) ),
SequencerSectionConstants::KeySize );
if( KeyGeometry.IsUnderLocation( MousePosition ) )
{
// The current key is under the mouse
return FSelectedKey( Section, KeyArea, KeyHandle );
}
}
// no key was selected in the current key area but the mouse is in the key area so it cannot possibly be in any other key area
return FSelectedKey();
}
}
// No key was selected in any key area
return FSelectedKey();
}
void SSection::DrawSectionBorders( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId ) const
{
UMovieSceneSection* SectionObject = SectionInterface->GetSectionObject();
FSequencerSelection& Selection = ParentSectionArea->GetSequencer().GetSelection();
const bool bSelected = Selection.IsSelected(SectionObject);
const bool bActive = Selection.GetActiveSelection() == FSequencerSelection::EActiveSelection::KeyAndSection;
static const FName SelectionColorName("SelectionColor");
static const FName SelectionInactiveColorName("SelectionColorInactive");
FLinearColor SelectionColor = FEditorStyle::GetSlateColor(SelectionColorName).GetColor(FWidgetStyle());
FLinearColor SelectionInactiveColor = FEditorStyle::GetSlateColor(SelectionInactiveColorName).GetColor(FWidgetStyle());
FLinearColor TransparentSelectionColor = SelectionColor;
static const FName SectionGripLeftName("Sequencer.SectionGripLeft");
static const FName SectionGripRightName("Sequencer.SectionGripRight");
// Left Grip
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
// Center the key along Y. Ensure the middle of the key is at the actual key time
AllottedGeometry.ToPaintGeometry( FVector2D( 0.0f, 0.0f ), FVector2D( SequencerSectionConstants::SectionGripSize, AllottedGeometry.GetDrawSize().Y) ) ,
FEditorStyle::GetBrush(SectionGripLeftName),
MyClippingRect,
ESlateDrawEffect::None,
(bLeftEdgePressed || bLeftEdgeHovered) ? TransparentSelectionColor : FLinearColor::White
);
// Right Grip
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
// Center the key along Y. Ensure the middle of the key is at the actual key time
AllottedGeometry.ToPaintGeometry( FVector2D( AllottedGeometry.Size.X-SequencerSectionConstants::SectionGripSize, 0.0f), FVector2D(SequencerSectionConstants::SectionGripSize, AllottedGeometry.GetDrawSize().Y)),
FEditorStyle::GetBrush(SectionGripRightName),
MyClippingRect,
ESlateDrawEffect::None,
(bRightEdgePressed || bRightEdgeHovered) ? TransparentSelectionColor : FLinearColor::White
);
// draw selection box
if(bSelected)
{
static const FName SelectionBorder("Sequencer.Section.SelectionBorder");
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush(SelectionBorder),
MyClippingRect,
ESlateDrawEffect::None,
bActive ? SelectionColor : SelectionInactiveColor
);
}
}
int32 SSection::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
int32 StartLayer = SCompoundWidget::OnPaint( Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled );
FGeometry SectionGeometry = AllottedGeometry.MakeChild( FVector2D( SequencerSectionConstants::SectionGripSize, 0 ), AllottedGeometry.GetDrawSize() - FVector2D( SequencerSectionConstants::SectionGripSize*2, 0.0f ) );
FSlateRect SectionClipRect = SectionGeometry.GetClippingRect().IntersectionWith( MyClippingRect );
// Ask the interface to draw the section
int32 PostSectionLayer = SectionInterface->OnPaintSection( SectionGeometry, SectionClipRect, OutDrawElements, LayerId, bParentEnabled );
DrawSectionBorders(AllottedGeometry, MyClippingRect, OutDrawElements, PostSectionLayer );
PaintKeys( SectionGeometry, MyClippingRect, OutDrawElements, PostSectionLayer, InWidgetStyle );
// Section name with drop shadow
FText SectionTitle = SectionInterface->GetSectionTitle();
if (!SectionTitle.IsEmpty())
{
FSlateDrawElement::MakeText(
OutDrawElements,
PostSectionLayer+1,
SectionGeometry.ToOffsetPaintGeometry(FVector2D(6, 6)),
SectionTitle,
FEditorStyle::GetFontStyle("NormalFont"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black
);
FSlateDrawElement::MakeText(
OutDrawElements,
PostSectionLayer+2,
SectionGeometry.ToOffsetPaintGeometry(FVector2D(5, 5)),
SectionTitle,
FEditorStyle::GetFontStyle("NormalFont"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::White
);
}
return LayerId;
}
FVector2D FGeometryHelper::CenterOf(const FGeometry& SomeGeometry)
{
const FVector2D GeometryDrawSize = SomeGeometry.GetDrawSize();
return SomeGeometry.AbsolutePosition + (GeometryDrawSize * 0.5f);
}
