void FSlateDrawElement::MakeDebugQuad( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FSlateRect& InClippingRect)
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, ESlateDrawEffect::None);
DrawElt.ElementType = ET_DebugQuad;
}
void FSlateDrawElement::MakeSpline( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FVector2D& InStart, const FVector2D& InStartDir, const FVector2D& InEnd, const FVector2D& InEndDir, const FSlateRect InClippingRect, float InThickness, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = ET_Spline;
DrawElt.DataPayload.SetSplinePayloadProperties( InStart, InStartDir, InEnd, InEndDir, InThickness, InTint );
}
void FSlateRHIRenderingPolicy::UpdateBuffers( const FSlateWindowElementList& WindowElementList )
{
SCOPE_CYCLE_COUNTER( STAT_SlateUpdateBufferRTTime );
// Should only be called by the rendering thread
check(IsInRenderingThread());
{
const TArray<FSlateVertex>& Vertices = WindowElementList.GetBatchedVertices();
const TArray<SlateIndex>& Indices = WindowElementList.GetBatchedIndices();
TSlateElementVertexBuffer<FSlateVertex>& VertexBuffer = VertexBuffers[CurrentBufferIndex];
FSlateElementIndexBuffer& IndexBuffer = IndexBuffers[CurrentBufferIndex];
VertexBuffer.FillBuffer( Vertices, bShouldShrinkResources );
IndexBuffer.FillBuffer( Indices, bShouldShrinkResources );
}
}
void FSlateDrawElement::MakeViewport( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, TSharedPtr<const ISlateViewport> Viewport, const FSlateRect& InClippingRect, bool bGammaCorrect, bool bAllowBlending, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = ET_Viewport;
DrawElt.DataPayload.SetViewportPayloadProperties( Viewport, InTint, bGammaCorrect, bAllowBlending );
}
void FSlateDrawElement::MakeText( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FText& InText, const FSlateFontInfo& InFontInfo, const FSlateRect& InClippingRect,ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = ET_Text;
DrawElt.DataPayload.SetTextPayloadProperties( InText.ToString(), InFontInfo, InTint );
}
void FSlateDrawElement::MakeCustom( FSlateWindowElementList& ElementList, uint32 InLayer, TSharedPtr<ICustomSlateElement, ESPMode::ThreadSafe> CustomDrawer )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Custom;
DrawElt.Layer = InLayer;
DrawElt.DataPayload.SetCustomDrawerPayloadProperties( CustomDrawer );
DrawElt.ClippingRect = FSlateRect(1,1,1,1);
}
void FSlateDrawElement::MakeGradient( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, TArray<FSlateGradientStop> InGradientStops, EOrientation InGradientType, const FSlateRect& InClippingRect, ESlateDrawEffect::Type InDrawEffects, bool bGammaCorrect )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = ET_Gradient;
DrawElt.DataPayload.SetGradientPayloadProperties( InGradientStops, InGradientType, bGammaCorrect );
}
void FSlateDrawElement::MakeLines( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const TArray<FVector2D>& Points, const FSlateRect InClippingRect, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint, bool bAntialias )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = ET_Line;
DrawElt.DataPayload.SetLinesPayloadProperties( Points, InTint, bAntialias, ESlateLineJoinType::Sharp );
}
void FSlateDrawElement::MakeCustom( FSlateWindowElementList& ElementList, uint32 InLayer, TSharedPtr<ICustomSlateElement, ESPMode::ThreadSafe> CustomDrawer )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, FPaintGeometry(), FSlateRect(1,1,1,1), ESlateDrawEffect::None);
DrawElt.RenderTransform = FSlateRenderTransform();
DrawElt.ElementType = ET_Custom;
DrawElt.DataPayload.SetCustomDrawerPayloadProperties( CustomDrawer );
}
int32 FSlateWindowElementList::FDeferredPaint::ExecutePaint( int32 LayerId, FSlateWindowElementList& OutDrawElements ) const
{
TSharedPtr<const SWidget> WidgetToPaint = WidgetToPaintPtr.Pin();
if ( WidgetToPaint.IsValid() )
{
return WidgetToPaint->Paint( Args, AllottedGeometry, OutDrawElements.GetWindow()->GetClippingRectangleInWindow(), OutDrawElements, LayerId, WidgetStyle, bParentEnabled );
}
return LayerId;
}
void FSlateDrawElement::MakeDebugQuad( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FSlateRect& InClippingRect)
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_DebugQuad;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.Size = PaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = ESlateDrawEffect::None;
DrawElt.Scale = PaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeLines( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const TArray<FVector2D>& Points, const FSlateRect InClippingRect, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint, bool bAntialias )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Line;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetLinesPayloadProperties( Points, InTint, bAntialias, ESlateLineJoinType::Sharp );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeSpline( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FVector2D& InStart, const FVector2D& InStartDir, const FVector2D& InEnd, const FVector2D& InEndDir, const FSlateRect InClippingRect, float InThickness, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Spline;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetSplinePayloadProperties( InStart, InStartDir, InEnd, InEndDir, InThickness, InTint );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
}
int32 STutorialWrapper::OnPaint(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
if(OnWidgetHighlightDelegate.IsBound() && OnWidgetHighlightDelegate.Execute(Name))
{
float AlphaFactor;
float PulseFactor;
FLinearColor ShadowTint;
FLinearColor BorderTint;
GetAnimationValues(AlphaFactor, PulseFactor, ShadowTint, BorderTint);
const FSlateBrush* ShadowBrush = FCoreStyle::Get().GetBrush(TEXT("Tutorials.Shadow"));
const FSlateBrush* BorderBrush = FCoreStyle::Get().GetBrush(TEXT("Tutorials.Border"));
const FGeometry& WidgetGeometry = CachedGeometry;
const FVector2D WindowPos = OutDrawElements.GetWindow()->GetPositionInScreen();
const FVector2D WindowSize = OutDrawElements.GetWindow()->GetSizeInScreen();
// We should be clipped by the window size, not our containing widget, as we want to draw outside the widget
FSlateRect WindowClippingRect(0.0f, 0.0f, WindowSize.X, WindowSize.Y);
// We want to draw on-top of everything else
int32 OverlayLayerId = MAX_int32 - 2;
FPaintGeometry ShadowGeometry((WidgetGeometry.AbsolutePosition - FVector2D(ShadowBrush->Margin.Left, ShadowBrush->Margin.Top) * ShadowBrush->ImageSize * WidgetGeometry.Scale * TutorialConstants::ShadowScale) - WindowPos,
((WidgetGeometry.Size * WidgetGeometry.Scale) + (FVector2D(ShadowBrush->Margin.Right * 2.0f, ShadowBrush->Margin.Bottom * 2.0f) * ShadowBrush->ImageSize * WidgetGeometry.Scale * TutorialConstants::ShadowScale)),
WidgetGeometry.Scale * TutorialConstants::ShadowScale);
// draw highlight shadow
FSlateDrawElement::MakeBox(OutDrawElements, OverlayLayerId + 0, ShadowGeometry, ShadowBrush, WindowClippingRect, ESlateDrawEffect::None, ShadowTint);
FVector2D PulseOffset = FVector2D(PulseFactor * TutorialConstants::MaxBorderOffset, PulseFactor * TutorialConstants::MaxBorderOffset);
FVector2D BorderPosition = (WidgetGeometry.AbsolutePosition - ((FVector2D(BorderBrush->Margin.Left, BorderBrush->Margin.Top) * BorderBrush->ImageSize * WidgetGeometry.Scale) + PulseOffset)) - WindowPos;
FVector2D BorderSize = ((WidgetGeometry.Size * WidgetGeometry.Scale) + (PulseOffset * 2.0f) + (FVector2D(BorderBrush->Margin.Right * 2.0f, BorderBrush->Margin.Bottom * 2.0f) * BorderBrush->ImageSize * WidgetGeometry.Scale));
FPaintGeometry BorderGeometry(BorderPosition, BorderSize, WidgetGeometry.Scale);
// draw highlight border
FSlateDrawElement::MakeBox(OutDrawElements, OverlayLayerId + 1, BorderGeometry, BorderBrush, WindowClippingRect, ESlateDrawEffect::None, BorderTint);
}
return SBorder::OnPaint(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
void FSlateDrawElement::MakeGradient( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& InPaintGeometry, TArray<FSlateGradientStop> InGradientStops, EOrientation InGradientType, const FSlateRect& InClippingRect, ESlateDrawEffect::Type InDrawEffects, bool bGammaCorrect )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Gradient;
DrawElt.Position = InPaintGeometry.DrawPosition;
DrawElt.Size = InPaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetGradientPayloadProperties( InGradientStops, InGradientType, bGammaCorrect );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = InPaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeViewport( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, TSharedPtr<const ISlateViewport> Viewport, const FSlateRect& InClippingRect, bool bGammaCorrect, bool bAllowBlending, ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Viewport;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.Size = PaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetViewportPayloadProperties( Viewport, InTint, bGammaCorrect, bAllowBlending );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeText( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FText& InText, const FSlateFontInfo& InFontInfo, const FSlateRect& InClippingRect,ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = ET_Text;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.Size = PaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetTextPayloadProperties( InText.ToString(), InFontInfo, InTint );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeBox(
FSlateWindowElementList& ElementList,
uint32 InLayer,
const FPaintGeometry& PaintGeometry,
const FSlateBrush* InBrush,
const FSlateRect& InClippingRect,
ESlateDrawEffect::Type InDrawEffects,
const FLinearColor& InTint )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = (InBrush->DrawAs == ESlateBrushDrawType::Border) ? ET_Border : ET_Box;
DrawElt.DataPayload.SetBoxPayloadProperties( InBrush, InTint );
}
int32 SMenuAnchor::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren( EVisibility::Visible );
ArrangeChildren( AllottedGeometry, ArrangedChildren );
// There may be zero elements in this array if our child collapsed/hidden
if ( ArrangedChildren.Num() > 0 )
{
const FArrangedWidget& FirstChild = ArrangedChildren[0];
// In the case where the user doesn't provide content to the menu anchor, the null widget
// wont appear in the visible set of arranged children, so only immediately paint the first child,
// if it's visible and matches the first slot content.
const bool bHasArrangedAnchorContent = FirstChild.Widget == Children[0].GetWidget();
if ( bHasArrangedAnchorContent )
{
const FSlateRect ChildClippingRect = AllottedGeometry.GetClippingRect().IntersectionWith(MyClippingRect);
LayerId = FirstChild.Widget->Paint(Args.WithNewParent(this), FirstChild.Geometry, ChildClippingRect, OutDrawElements, LayerId + 1, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
}
const bool bIsOpen = IsOpen();
if ( bIsOpen )
{
// In the case where the anchor content is present and visible, it's the 1 index child, in the case
// where the anchor content is invisible, it's the 0 index child.
FArrangedWidget* PopupChild = nullptr;
if ( bHasArrangedAnchorContent && ArrangedChildren.Num() > 1 )
{
PopupChild = &ArrangedChildren[1];
}
else if ( !bHasArrangedAnchorContent && ArrangedChildren.Num() == 1 )
{
PopupChild = &ArrangedChildren[0];
}
if ( PopupChild != nullptr )
{
OutDrawElements.QueueDeferredPainting(
FSlateWindowElementList::FDeferredPaint(PopupChild->Widget, Args, PopupChild->Geometry, MyClippingRect, InWidgetStyle, bParentEnabled));
}
}
}
return LayerId;
}
int32 STutorialButton::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
LayerId = SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled) + 1000;
if ( PulseAnimation.IsPlaying() )
{
float AlphaFactor0 = 0.0f;
float AlphaFactor1 = 0.0f;
float PulseFactor0 = 0.0f;
float PulseFactor1 = 0.0f;
GetAnimationValues(PulseAnimation.GetLerp(), AlphaFactor0, PulseFactor0, AlphaFactor1, PulseFactor1);
const FSlateBrush* PulseBrush = FEditorStyle::Get().GetBrush(TEXT("TutorialLaunch.Circle"));
const FLinearColor PulseColor = FEditorStyle::Get().GetColor(TEXT("TutorialLaunch.Circle.Color"));
// We should be clipped by the window size, not our containing widget, as we want to draw outside the widget
const FVector2D WindowSize = OutDrawElements.GetWindow()->GetSizeInScreen();
FSlateRect WindowClippingRect(0.0f, 0.0f, WindowSize.X, WindowSize.Y);
{
FVector2D PulseOffset = FVector2D(PulseFactor0 * TutorialButtonConstants::MaxPulseOffset, PulseFactor0 * TutorialButtonConstants::MaxPulseOffset);
FVector2D BorderPosition = (AllottedGeometry.AbsolutePosition - ((FVector2D(PulseBrush->Margin.Left, PulseBrush->Margin.Top) * PulseBrush->ImageSize * AllottedGeometry.Scale) + PulseOffset));
FVector2D BorderSize = ((AllottedGeometry.Size * AllottedGeometry.Scale) + (PulseOffset * 2.0f) + (FVector2D(PulseBrush->Margin.Right * 2.0f, PulseBrush->Margin.Bottom * 2.0f) * PulseBrush->ImageSize * AllottedGeometry.Scale));
FPaintGeometry BorderGeometry(BorderPosition, BorderSize, AllottedGeometry.Scale);
// draw highlight border
FSlateDrawElement::MakeBox(OutDrawElements, LayerId++, BorderGeometry, PulseBrush, WindowClippingRect, ESlateDrawEffect::None, FLinearColor(PulseColor.R, PulseColor.G, PulseColor.B, AlphaFactor0));
}
{
FVector2D PulseOffset = FVector2D(PulseFactor1 * TutorialButtonConstants::MaxPulseOffset, PulseFactor1 * TutorialButtonConstants::MaxPulseOffset);
FVector2D BorderPosition = (AllottedGeometry.AbsolutePosition - ((FVector2D(PulseBrush->Margin.Left, PulseBrush->Margin.Top) * PulseBrush->ImageSize * AllottedGeometry.Scale) + PulseOffset));
FVector2D BorderSize = ((AllottedGeometry.Size * AllottedGeometry.Scale) + (PulseOffset * 2.0f) + (FVector2D(PulseBrush->Margin.Right * 2.0f, PulseBrush->Margin.Bottom * 2.0f) * PulseBrush->ImageSize * AllottedGeometry.Scale));
FPaintGeometry BorderGeometry(BorderPosition, BorderSize, AllottedGeometry.Scale);
// draw highlight border
FSlateDrawElement::MakeBox(OutDrawElements, LayerId++, BorderGeometry, PulseBrush, WindowClippingRect, ESlateDrawEffect::None, FLinearColor(PulseColor.R, PulseColor.G, PulseColor.B, AlphaFactor1));
}
}
return LayerId;
}
void FSlateDrawElement::MakeBox(
FSlateWindowElementList& ElementList,
uint32 InLayer,
const FPaintGeometry& PaintGeometry,
const FSlateBrush* InBrush,
const FSlateRect& InClippingRect,
ESlateDrawEffect::Type InDrawEffects,
const FLinearColor& InTint )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = (InBrush->DrawAs == ESlateBrushDrawType::Border) ? ET_Border : ET_Box;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.Size = PaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.DataPayload.SetBoxPayloadProperties( InBrush, InTint );
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
}
void FSlateDrawElement::MakeRotatedBox(
FSlateWindowElementList& ElementList,
uint32 InLayer,
const FPaintGeometry& PaintGeometry,
const FSlateBrush* InBrush,
const FSlateRect& InClippingRect,
ESlateDrawEffect::Type InDrawEffects,
float Angle,
TOptional<FVector2D> InRotationPoint,
ERotationSpace RotationSpace,
const FLinearColor& InTint )
{
PaintGeometry.CommitTransformsIfUsingLegacyConstructor();
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.Init(InLayer, PaintGeometry, InClippingRect, InDrawEffects);
DrawElt.ElementType = (InBrush->DrawAs == ESlateBrushDrawType::Border) ? ET_Border : ET_Box;
FVector2D RotationPoint = GetRotationPoint( PaintGeometry, InRotationPoint, RotationSpace );
DrawElt.DataPayload.SetRotatedBoxPayloadProperties( InBrush, Angle, RotationPoint, InTint );
}
int32 SPopup::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// There may be zero elements in this array if our child collapsed/hidden
if (ArrangedChildren.Num() > 0)
{
check(ArrangedChildren.Num() == 1);
FArrangedWidget& TheChild = ArrangedChildren[0];
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor(GetForegroundColor());
// An SPopup just queues up its children to be painted after everything in this window is done painting.
OutDrawElements.QueueDeferredPainting(
FSlateWindowElementList::FDeferredPaint(TheChild.Widget, Args.WithNewParent(this), TheChild.Geometry, MyClippingRect, CompoundedWidgetStyle, ShouldBeEnabled(bParentEnabled))
);
}
return LayerId;
}
void FSlateDrawElement::MakeRotatedBox(
FSlateWindowElementList& ElementList,
uint32 InLayer,
const FPaintGeometry& PaintGeometry,
const FSlateBrush* InBrush,
const FSlateRect& InClippingRect,
ESlateDrawEffect::Type InDrawEffects,
float Angle,
TOptional<FVector2D> InRotationPoint,
ERotationSpace RotationSpace,
const FLinearColor& InTint )
{
FSlateDrawElement& DrawElt = ElementList.AddUninitialized();
DrawElt.ElementType = (InBrush->DrawAs == ESlateBrushDrawType::Border) ? ET_Border : ET_Box;
DrawElt.Position = PaintGeometry.DrawPosition;
DrawElt.Size = PaintGeometry.DrawSize;
DrawElt.ClippingRect = InClippingRect;
DrawElt.Layer = InLayer;
DrawElt.DrawEffects = InDrawEffects;
DrawElt.Scale = PaintGeometry.DrawScale;
FVector2D RotationPoint = GetRotationPoint( PaintGeometry, InRotationPoint, RotationSpace );
DrawElt.DataPayload.SetRotatedBoxPayloadProperties( InBrush, Angle, RotationPoint, InTint );
}
int32 SInvalidationPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
if ( GetCanCache() )
{
const bool bWasCachingNeeded = bNeedsCaching;
if ( bNeedsCaching )
{
SInvalidationPanel* MutableThis = const_cast<SInvalidationPanel*>( this );
// Always set the caching flag to false first, during the paint / tick pass we may change something
// to volatile and need to re-cache.
bNeedsCaching = false;
bIsInvalidating = true;
if ( !CachedWindowElements.IsValid() || CachedWindowElements->GetWindow() != OutDrawElements.GetWindow() )
{
CachedWindowElements = MakeShareable(new FSlateWindowElementList(OutDrawElements.GetWindow()));
}
else
{
CachedWindowElements->Reset();
}
// Reset the cached node pool index so that we effectively reset the pool.
LastUsedCachedNodeIndex = 0;
RootCacheNode = CreateCacheNode();
RootCacheNode->Initialize(Args, SharedThis(MutableThis), AllottedGeometry, MyClippingRect);
//TODO: When SWidget::Paint is called don't drag self if volatile, and we're doing a cache pass.
CachedMaxChildLayer = SCompoundWidget::OnPaint(
Args.EnableCaching(SharedThis(MutableThis), RootCacheNode, true, false),
AllottedGeometry,
MyClippingRect,
*CachedWindowElements.Get(),
LayerId,
InWidgetStyle,
bParentEnabled);
if ( bCacheRelativeTransforms )
{
CachedAbsolutePosition = AllottedGeometry.Position;
}
LastLayerId = LayerId;
LastHitTestIndex = Args.GetLastHitTestIndex();
bIsInvalidating = false;
}
// The hit test grid is actually populated during the initial cache phase, so don't bother
// recording the hit test geometry on the same frame that we regenerate the cache.
if ( bWasCachingNeeded == false )
{
RootCacheNode->RecordHittestGeometry(Args.GetGrid(), Args.GetLastHitTestIndex());
}
if ( bCacheRelativeTransforms )
{
FVector2D DeltaPosition = AllottedGeometry.Position - CachedAbsolutePosition;
const TArray<FSlateDrawElement>& CachedElements = CachedWindowElements->GetDrawElements();
const int32 CachedElementCount = CachedElements.Num();
for ( int32 Index = 0; Index < CachedElementCount; Index++ )
{
const FSlateDrawElement& LocalElement = CachedElements[Index];
FSlateDrawElement AbsElement = LocalElement;
AbsElement.SetPosition(LocalElement.GetPosition() + DeltaPosition);
AbsElement.SetClippingRect(LocalElement.GetClippingRect().OffsetBy(DeltaPosition));
OutDrawElements.AddItem(AbsElement);
}
}
else
{
OutDrawElements.AppendDrawElements(CachedWindowElements->GetDrawElements());
}
int32 OutMaxChildLayer = CachedMaxChildLayer;
// Paint the volatile elements
if ( CachedWindowElements.IsValid() )
{
OutMaxChildLayer = FMath::Max(CachedMaxChildLayer, CachedWindowElements->PaintVolatile(OutDrawElements));
}
#if !UE_BUILD_SHIPPING
if ( IsInvalidationDebuggingEnabled() )
{
// Draw a green or red border depending on if we were invalidated this frame.
{
check(Args.IsCaching() == false);
//const bool bShowOutlineAsCached = Args.IsCaching() || bWasCachingNeeded == false;
const FLinearColor DebugTint = bWasCachingNeeded ? FLinearColor::Red : FLinearColor::Green;
FGeometry ScaledOutline = AllottedGeometry.MakeChild(FVector2D(0, 0), AllottedGeometry.GetLocalSize() * AllottedGeometry.Scale, Inverse(AllottedGeometry.Scale));
FSlateDrawElement::MakeBox(
OutDrawElements,
++OutMaxChildLayer,
ScaledOutline.ToPaintGeometry(),
FCoreStyle::Get().GetBrush(TEXT("Debug.Border")),
MyClippingRect,
ESlateDrawEffect::None,
DebugTint
);
}
// Draw a yellow outline around any volatile elements.
const TArray< TSharedRef<FSlateWindowElementList::FVolatilePaint> >& VolatileElements = CachedWindowElements->GetVolatileElements();
for ( const TSharedRef<FSlateWindowElementList::FVolatilePaint>& VolatileElement : VolatileElements )
{
FSlateDrawElement::MakeBox(
OutDrawElements,
++OutMaxChildLayer,
VolatileElement->GetGeometry().ToPaintGeometry(),
FCoreStyle::Get().GetBrush(TEXT("FocusRectangle")),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Yellow
);
}
// Draw a white flash for any widget that invalidated us this frame.
for ( TWeakPtr<SWidget> Invalidator : InvalidatorWidgets )
{
TSharedPtr<SWidget> SafeInvalidator = Invalidator.Pin();
if ( SafeInvalidator.IsValid() )
{
FWidgetPath WidgetPath;
if ( FSlateApplication::Get().GeneratePathToWidgetUnchecked(SafeInvalidator.ToSharedRef(), WidgetPath, EVisibility::All) )
{
FArrangedWidget ArrangedWidget = WidgetPath.FindArrangedWidget(SafeInvalidator.ToSharedRef()).Get(FArrangedWidget::NullWidget);
ArrangedWidget.Geometry.AppendTransform( FSlateLayoutTransform(Inverse(Args.GetWindowToDesktopTransform())) );
FSlateDrawElement::MakeBox(
OutDrawElements,
++OutMaxChildLayer,
ArrangedWidget.Geometry.ToPaintGeometry(),
FCoreStyle::Get().GetBrush(TEXT("WhiteBrush")),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::White.CopyWithNewOpacity(0.6f)
);
}
}
}
InvalidatorWidgets.Reset();
}
#endif
return OutMaxChildLayer;
}
else
{
return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
}
int32 SWidget::Paint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
INC_DWORD_STAT(STAT_SlateNumPaintedWidgets);
SLATE_CYCLE_COUNTER_SCOPE_CUSTOM_DETAILED(SLATE_STATS_DETAIL_LEVEL_MED, GSlateOnPaint, GetType());
// Save the current layout cache we're associated with (if any)
LayoutCache = Args.GetLayoutCache();
// Record if we're part of a volatility pass, this is critical for ensuring we don't report a child
// of a volatile widget as non-volatile, causing the invalidation panel to do work that's not required.
bInheritedVolatility = Args.IsVolatilityPass();
// If this paint pass is to cache off our geometry, but we're a volatile widget,
// record this widget as volatile in the draw elements so that we get our own tick/paint
// pass later when the layout cache draws.
if ( Args.IsCaching() && IsVolatile() )
{
const int32 VolatileLayerId = LayerId + 1;
OutDrawElements.QueueVolatilePainting(
FSlateWindowElementList::FVolatilePaint(SharedThis(this), Args, AllottedGeometry, MyClippingRect, VolatileLayerId, InWidgetStyle, bParentEnabled));
return VolatileLayerId;
}
if ( bFoldTick && bCanTick )
{
FGeometry TickGeometry = AllottedGeometry;
TickGeometry.AppendTransform( FSlateLayoutTransform(Args.GetWindowToDesktopTransform()) );
SWidget* MutableThis = const_cast<SWidget*>(this);
MutableThis->ExecuteActiveTimers( Args.GetCurrentTime(), Args.GetDeltaTime() );
MutableThis->Tick( TickGeometry, Args.GetCurrentTime(), Args.GetDeltaTime() );
}
// Record hit test geometry, but only if we're not caching.
const FPaintArgs UpdatedArgs = Args.RecordHittestGeometry(this, AllottedGeometry, MyClippingRect);
// Paint the geometry of this widget.
int32 NewLayerID = OnPaint(UpdatedArgs, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
// Check if we need to show the keyboard focus ring, this is only necessary if the widget could be focused.
if ( bCanSupportFocus && SupportsKeyboardFocus() )
{
bool bShowUserFocus = FSlateApplicationBase::Get().ShowUserFocus(SharedThis(this));
if (bShowUserFocus)
{
const FSlateBrush* BrushResource = GetFocusBrush();
if (BrushResource != nullptr)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
NewLayerID,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
MyClippingRect,
ESlateDrawEffect::None,
BrushResource->GetTint(InWidgetStyle)
);
}
}
}
return NewLayerID;
}
