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;
}
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);
}
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;
}
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);
}
}