/**
* This widget was created before render transforms existed for each widget, and it chose to apply the render transform AFTER the layout transform.
* This means leveraging the render transform of FGeometry would be expensive, as we would need to use Concat(LayoutTransform, RenderTransform, Inverse(LayoutTransform).
* Instead, we maintain the old way of doing it by modifying the AllottedGeometry only during rendering to append the widget's implied RenderTransform to the existing LayoutTransform.
*/
int32 SFxWidget::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Convert the 0..1 origin into local space extents.
const FVector2D ScaleOrigin = RenderScaleOrigin.Get() * AllottedGeometry.Size;
const FVector2D Offset = VisualOffset.Get() * AllottedGeometry.Size;
// create the render transform as a scale around ScaleOrigin and offset it by Offset.
const auto RenderTransform = Concatenate(Inverse(ScaleOrigin), RenderScale.Get(), ScaleOrigin, Offset);
// This will append the render transform to the layout transform, and we only use it for rendering.
FGeometry ModifiedGeometry = AllottedGeometry.MakeChild(AllottedGeometry.Size, RenderTransform);
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(ModifiedGeometry, ArrangedChildren);
// There may be zero elements in this array if our child collapsed/hidden
if( ArrangedChildren.Num() > 0 )
{
// We can only have one direct descendant.
check( ArrangedChildren.Num() == 1 );
const FArrangedWidget& TheChild = ArrangedChildren[0];
// SFxWidgets are able to ignore parent clipping.
const FSlateRect ChildClippingRect = (bIgnoreClipping.Get())
? ModifiedGeometry.GetClippingRect()
: MyClippingRect.IntersectionWith(ModifiedGeometry.GetClippingRect());
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor( ForegroundColor );
return TheChild.Widget->Paint( Args.WithNewParent(this), TheChild.Geometry, ChildClippingRect, OutDrawElements, LayerId + 1, CompoundedWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
/** SWidget Interface */
int32 SSequencerSectionAreaView::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);
if( SectionAreaNode.IsValid() )
{
// Draw a region around the entire section area
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BackgroundBrush,
MyClippingRect,
ESlateDrawEffect::None,
SequencerSectionAreaConstants::BackgroundColor
);
}
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, LayerId+1, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId+1;
}
int32 SBorder::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateBrush* BrushResource = BorderImage.Get();
const bool bEnabled = ShouldBeEnabled(bParentEnabled);
const bool bShowDisabledEffect = ShowDisabledEffect.Get();
ESlateDrawEffect::Type DrawEffects = bShowDisabledEffect && !bEnabled ? ESlateDrawEffect::DisabledEffect : ESlateDrawEffect::None;
if ( BrushResource && BrushResource->DrawAs != ESlateBrushDrawType::NoDrawType )
{
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
MyClippingRect,
DrawEffects,
BrushResource->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * BorderBackgroundColor.Get().GetColor( InWidgetStyle )
);
}
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor( ForegroundColor.Get() );
return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect.IntersectionWith( AllottedGeometry.GetClippingRect() ), OutDrawElements, LayerId, CompoundedWidgetStyle, bEnabled );
}
int32 SPanel::PaintArrangedChildren( const FPaintArgs& Args, const FArrangedChildren& ArrangedChildren, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
const FPaintArgs NewArgs = Args.WithNewParent(this);
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
const FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
bool bWereOverlapping;
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith(CurWidget.Geometry.GetClippingRect(), bWereOverlapping);
if ( bWereOverlapping )
{
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint(NewArgs, CurWidget.Geometry, ChildClipRect, OutDrawElements, LayerId, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
MaxLayerId = FMath::Max(MaxLayerId, CurWidgetsMaxLayerId);
}
}
return MaxLayerId;
}
int32 SDockingTabWell::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// When we are dragging a tab, it must be painted on top of the other tabs, so we cannot
// just reuse the Panel's default OnPaint.
// The TabWell has no visualization of its own; it just visualizes its child tabs.
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
TSharedPtr<SDockTab> ForegroundTab = GetForegroundTab();
FArrangedWidget* ForegroundTabGeometry = NULL;
// Draw all inactive tabs first
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
if (CurWidget.Widget == ForegroundTab)
{
ForegroundTabGeometry = &CurWidget;
}
else
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, MaxLayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
// Draw active tab in front
if (ForegroundTab != TSharedPtr<SDockTab>())
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( ForegroundTabGeometry->Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = ForegroundTabGeometry->Widget->Paint( Args.WithNewParent(this), ForegroundTabGeometry->Geometry, ChildClipRect, OutDrawElements, MaxLayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
return MaxLayerId;
}
int32 SGridPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::All);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
// We need to iterate over slots, because slots know the GridLayers. This isn't available in the arranged children.
// Some slots do not show up (they are hidden/collapsed). We need a 2nd index to skip over them.
//
// GridLayers must ensure that everything in LayerN is below LayerN+1. In other words,
// every grid layer group must start at the current MaxLayerId (similar to how SOverlay works).
int32 LastGridLayer = 0;
for (int32 ChildIndex = 0; ChildIndex < Slots.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
if (CurWidget.Widget->GetVisibility().IsVisible())
{
const FSlot& CurSlot = Slots[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
if ( LastGridLayer != CurSlot.LayerParam )
{
// We starting a new grid layer group?
LastGridLayer = CurSlot.LayerParam;
// Ensure that everything here is drawn on top of
// previously drawn grid content.
LayerId = MaxLayerId+1;
}
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint(
Args.WithNewParent(this),
CurWidget.Geometry,
ChildClipRect,
OutDrawElements,
LayerId,
InWidgetStyle,
ShouldBeEnabled( bParentEnabled )
);
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
//#define LAYOUT_DEBUG
#ifdef LAYOUT_DEBUG
LayerId = LayoutDebugPaint( AllottedGeometry, MyClippingRect, OutDrawElements, LayerId );
#endif
return MaxLayerId;
}
int32 SConstraintCanvas::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);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith(CurWidget.Geometry.GetClippingRect());
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, MaxLayerId + 1, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
MaxLayerId = FMath::Max(MaxLayerId, CurWidgetsMaxLayerId);
}
return MaxLayerId;
}
int32 SSequencerTrackArea::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);
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 ThisWidgetLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, LayerId + 1, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
LayerId = FMath::Max(LayerId, ThisWidgetLayerId);
}
auto SequencerPin = SequencerWidget.Pin();
if (SequencerPin.IsValid())
{
return SequencerPin->GetEditTool().OnPaint(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId + 1);
}
return LayerId;
}
int32 SResponsiveGridPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::All);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
// We need to iterate over slots, because slots know the GridLayers. This isn't available in the arranged children.
// Some slots do not show up (they are hidden/collapsed). We need a 2nd index to skip over them.
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
if (CurWidget.Widget->GetVisibility().IsVisible())
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint(
Args.WithNewParent(this),
CurWidget.Geometry,
ChildClipRect,
OutDrawElements,
LayerId,
InWidgetStyle,
ShouldBeEnabled( bParentEnabled )
);
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
#ifdef LAYOUT_DEBUG
LayerId = LayoutDebugPaint( AllottedGeometry, MyClippingRect, OutDrawElements, LayerId );
#endif
return MaxLayerId;
}
int32 SProgressBar::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Used to track the layer ID we will return.
int32 RetLayerId = LayerId;
bool bEnabled = ShouldBeEnabled( bParentEnabled );
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const FSlateBrush* CurrentFillImage = GetFillImage();
const FLinearColor FillColorAndOpacitySRGB(InWidgetStyle.GetColorAndOpacityTint() * FillColorAndOpacity.Get().GetColor(InWidgetStyle) * CurrentFillImage->GetTint(InWidgetStyle));
const FLinearColor ColorAndOpacitySRGB = InWidgetStyle.GetColorAndOpacityTint();
TOptional<float> ProgressFraction = Percent.Get();
// Paint inside the border only.
// Pre-snap the clipping rect to try and reduce common jitter, since the padding is typically only a single pixel.
FSlateRect SnappedClippingRect = FSlateRect(FMath::RoundToInt(MyClippingRect.Left), FMath::RoundToInt(MyClippingRect.Top), FMath::RoundToInt(MyClippingRect.Right), FMath::RoundToInt(MyClippingRect.Bottom));
const FSlateRect ForegroundClippingRect = SnappedClippingRect.InsetBy(FMargin(BorderPadding.Get().X, BorderPadding.Get().Y));
const FSlateBrush* CurrentBackgroundImage = GetBackgroundImage();
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(),
CurrentBackgroundImage,
SnappedClippingRect,
DrawEffects,
InWidgetStyle.GetColorAndOpacityTint() * CurrentBackgroundImage->GetTint( InWidgetStyle )
);
if( ProgressFraction.IsSet() )
{
const float ClampedFraction = FMath::Clamp(ProgressFraction.GetValue(), 0.0f, 1.0f);
switch (BarFillType)
{
case EProgressBarFillType::RightToLeft:
{
FSlateRect ClippedAllotedGeometry = FSlateRect(AllottedGeometry.AbsolutePosition, AllottedGeometry.AbsolutePosition + AllottedGeometry.Size * AllottedGeometry.Scale);
ClippedAllotedGeometry.Left = ClippedAllotedGeometry.Right - ClippedAllotedGeometry.GetSize().X * ClampedFraction;
// Draw Fill
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D::ZeroVector,
FVector2D( AllottedGeometry.Size.X, AllottedGeometry.Size.Y )),
CurrentFillImage,
ForegroundClippingRect.IntersectionWith(ClippedAllotedGeometry),
DrawEffects,
FillColorAndOpacitySRGB
);
break;
}
case EProgressBarFillType::FillFromCenter:
{
// Draw Fill
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D( (AllottedGeometry.Size.X * 0.5f) - ((AllottedGeometry.Size.X * ( ClampedFraction ))*0.5), 0.0f),
FVector2D( AllottedGeometry.Size.X * ( ClampedFraction ) , AllottedGeometry.Size.Y )),
CurrentFillImage,
ForegroundClippingRect,
DrawEffects,
FillColorAndOpacitySRGB
);
break;
}
case EProgressBarFillType::TopToBottom:
{
FSlateRect ClippedAllotedGeometry = FSlateRect(AllottedGeometry.AbsolutePosition, AllottedGeometry.AbsolutePosition + AllottedGeometry.Size * AllottedGeometry.Scale);
ClippedAllotedGeometry.Bottom = ClippedAllotedGeometry.Top + ClippedAllotedGeometry.GetSize().Y * ClampedFraction;
// Draw Fill
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D::ZeroVector,
FVector2D( AllottedGeometry.Size.X, AllottedGeometry.Size.Y )),
CurrentFillImage,
ForegroundClippingRect.IntersectionWith(ClippedAllotedGeometry),
DrawEffects,
FillColorAndOpacitySRGB
);
break;
}
case EProgressBarFillType::BottomToTop:
{
FSlateRect ClippedAllotedGeometry = FSlateRect(AllottedGeometry.AbsolutePosition, AllottedGeometry.AbsolutePosition + AllottedGeometry.Size * AllottedGeometry.Scale);
ClippedAllotedGeometry.Top = ClippedAllotedGeometry.Bottom - ClippedAllotedGeometry.GetSize().Y * ClampedFraction;
// Draw Fill
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D::ZeroVector,
FVector2D( AllottedGeometry.Size.X, AllottedGeometry.Size.Y )),
CurrentFillImage,
ForegroundClippingRect.IntersectionWith(ClippedAllotedGeometry),
DrawEffects,
FillColorAndOpacitySRGB
);
break;
}
case EProgressBarFillType::LeftToRight:
default:
{
FSlateRect ClippedAllotedGeometry = FSlateRect(AllottedGeometry.AbsolutePosition, AllottedGeometry.AbsolutePosition + AllottedGeometry.Size * AllottedGeometry.Scale);
ClippedAllotedGeometry.Right = ClippedAllotedGeometry.Left + ClippedAllotedGeometry.GetSize().X * ClampedFraction;
// Draw Fill
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D::ZeroVector,
FVector2D( AllottedGeometry.Size.X, AllottedGeometry.Size.Y )),
CurrentFillImage,
ForegroundClippingRect.IntersectionWith(ClippedAllotedGeometry),
DrawEffects,
FillColorAndOpacitySRGB
);
break;
}
}
}
else
{
const FSlateBrush* CurrentMarqueeImage = GetMarqueeImage();
// Draw Marquee
const float MarqueeAnimOffset = CurrentMarqueeImage->ImageSize.X * MarqueeOffset;
const float MarqueeImageSize = CurrentMarqueeImage->ImageSize.X;
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D( MarqueeAnimOffset - MarqueeImageSize, 0.0f ),
FVector2D( AllottedGeometry.Size.X + MarqueeImageSize, AllottedGeometry.Size.Y )),
CurrentMarqueeImage,
ForegroundClippingRect,
DrawEffects,
ColorAndOpacitySRGB
);
}
return RetLayerId - 1;
}
int32 FSlateTextLayout::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateRect ClippingRect = AllottedGeometry.GetClippingRect().IntersectionWith(MyClippingRect);
const ESlateDrawEffect::Type DrawEffects = bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
static bool ShowDebug = false;
FLinearColor BlockHue( 0, 1.0f, 1.0f, 0.5 );
int32 HighestLayerId = LayerId;
for (const FTextLayout::FLineView& LineView : LineViews)
{
// Is this line visible?
const FSlateRect LineViewRect(AllottedGeometry.AbsolutePosition + LineView.Offset, AllottedGeometry.AbsolutePosition + LineView.Offset + LineView.Size);
const FSlateRect VisibleLineView = ClippingRect.IntersectionWith(LineViewRect);
if (VisibleLineView.IsEmpty())
{
continue;
}
// Render any underlays for this line
const int32 HighestUnderlayLayerId = OnPaintHighlights( Args, LineView, LineView.UnderlayHighlights, DefaultTextStyle, AllottedGeometry, ClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled );
const int32 BlockDebugLayer = HighestUnderlayLayerId;
const int32 TextLayer = BlockDebugLayer + 1;
int32 HighestBlockLayerId = TextLayer;
// Render every block for this line
for (const TSharedRef< ILayoutBlock >& Block : LineView.Blocks)
{
if ( ShowDebug )
{
BlockHue.R += 50.0f;
// The block size and offset values are pre-scaled, so we need to account for that when converting the block offsets into paint geometry
const float InverseScale = Inverse(AllottedGeometry.Scale);
FSlateDrawElement::MakeBox(
OutDrawElements,
BlockDebugLayer,
AllottedGeometry.ToPaintGeometry(TransformVector(InverseScale, Block->GetSize()), FSlateLayoutTransform(TransformPoint(InverseScale, Block->GetLocationOffset()))),
&DefaultTextStyle.HighlightShape,
ClippingRect,
DrawEffects,
InWidgetStyle.GetColorAndOpacityTint() * BlockHue.HSVToLinearRGB()
);
}
const TSharedRef< ISlateRun > Run = StaticCastSharedRef< ISlateRun >( Block->GetRun() );
int32 HighestRunLayerId = TextLayer;
const TSharedPtr< ISlateRunRenderer > RunRenderer = StaticCastSharedPtr< ISlateRunRenderer >( Block->GetRenderer() );
if ( RunRenderer.IsValid() )
{
HighestRunLayerId = RunRenderer->OnPaint( Args, LineView, Run, Block, DefaultTextStyle, AllottedGeometry, ClippingRect, OutDrawElements, TextLayer, InWidgetStyle, bParentEnabled );
}
else
{
HighestRunLayerId = Run->OnPaint( Args, LineView, Block, DefaultTextStyle, AllottedGeometry, ClippingRect, OutDrawElements, TextLayer, InWidgetStyle, bParentEnabled );
}
HighestBlockLayerId = FMath::Max( HighestBlockLayerId, HighestRunLayerId );
}
// Render any overlays for this line
const int32 HighestOverlayLayerId = OnPaintHighlights( Args, LineView, LineView.OverlayHighlights, DefaultTextStyle, AllottedGeometry, ClippingRect, OutDrawElements, HighestBlockLayerId, InWidgetStyle, bParentEnabled );
HighestLayerId = FMath::Max( HighestLayerId, HighestOverlayLayerId );
}
return HighestLayerId;
}
