int32 FColorPropertySection::OnPaintSection( const FGeometry& AllottedGeometry, const FSlateRect& SectionClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bParentEnabled ) const
{
const ESlateDrawEffect::Type DrawEffects = bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const UMovieSceneColorSection* ColorSection = Cast<const UMovieSceneColorSection>( &SectionObject );
float StartTime = ColorSection->GetStartTime();
float EndTime = ColorSection->GetEndTime();
float SectionDuration = EndTime - StartTime;
if ( !FMath::IsNearlyZero( SectionDuration ) )
{
LayerId = FPropertySection::OnPaintSection( AllottedGeometry, SectionClippingRect, OutDrawElements, LayerId, bParentEnabled );
FVector2D GradientSize = FVector2D( AllottedGeometry.Size.X, (AllottedGeometry.Size.Y / 4) - 3.0f );
FPaintGeometry PaintGeometry = AllottedGeometry.ToPaintGeometry( FVector2D( 0, 0 ), GradientSize );
// If we are showing a background pattern and the colors is transparent, draw a checker pattern
const FSlateBrush* CheckerBrush = FEditorStyle::GetBrush( "Checker" );
FSlateDrawElement::MakeBox( OutDrawElements, LayerId, PaintGeometry, CheckerBrush, SectionClippingRect, DrawEffects );
TArray<FSlateGradientStop> GradientStops;
TArray< TKeyValuePair<float, FLinearColor> > ColorKeys;
ConsolidateColorCurves( ColorKeys, ColorSection );
for ( int32 i = 0; i < ColorKeys.Num(); ++i )
{
float Time = ColorKeys[i].Key;
FLinearColor Color = ColorKeys[i].Value;
float TimeFraction = (Time - StartTime) / SectionDuration;
GradientStops.Add( FSlateGradientStop( FVector2D( TimeFraction * AllottedGeometry.Size.X, 0 ),
Color ) );
}
if ( GradientStops.Num() > 0 )
{
FSlateDrawElement::MakeGradient(
OutDrawElements,
LayerId + 1,
PaintGeometry,
GradientStops,
Orient_Vertical,
SectionClippingRect,
DrawEffects
);
}
}
return LayerId + 1;
}
int32 SColorGradientEditor::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const TSharedRef< FSlateFontMeasure > FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
if( CurveOwner )
{
// Split the geometry into areas for stops and the gradient
FGeometry ColorMarkAreaGeometry = GetColorMarkAreaGeometry( AllottedGeometry );
FGeometry AlphaMarkAreaGeometry = GetAlphaMarkAreaGeometry( AllottedGeometry );
FGeometry GradientAreaGeometry = AllottedGeometry.MakeChild( FVector2D(0.0f, 16.0f), FVector2D( AllottedGeometry.Size.X, AllottedGeometry.Size.Y - 30.0f ) );
bool bEnabled = ShouldBeEnabled( bParentEnabled );
ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
// Pixel to value input converter
FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), 0.0f, 1.0f, GradientAreaGeometry.Size);
// The start and end location in slate units of the area to draw
int32 Start = 0;
int32 Finish = FMath::TruncToInt( AllottedGeometry.Size.X );
TArray<FSlateGradientStop> Stops;
// If no alpha keys are available, treat the curve as being completely opaque for drawing purposes
bool bHasAnyAlphaKeys = CurveOwner->HasAnyAlphaKeys();
// If any transpareny (A < 1) is found, we'll draw a checkerboard to visualize the color with alpha
bool bHasTransparency = false;
// Sample the curve every 2 units. THe curve could be non-linear so sampling at each stop would display an incorrect gradient
for( int32 CurrentStep = Start; CurrentStep < Finish; CurrentStep+=2 )
{
// Figure out the time from the current screen unit
float Time = ScaleInfo.LocalXToInput(CurrentStep);
// Sample the curve
FLinearColor Color = CurveOwner->GetLinearColorValue( Time );
if( !bHasAnyAlphaKeys )
{
// Only show alpha if there is at least one key. For some curves, alpha may not be important
Color.A = 1.0f;
bHasTransparency = false;
}
else
{
bHasTransparency |= (Color.A < 1.0f);
}
Stops.Add( FSlateGradientStop( FVector2D( CurrentStep, 0.0f ), Color ) );
}
if( Stops.Num() > 0 )
{
if( bHasTransparency )
{
// Draw a checkerboard behind there is any transparency visible
FSlateDrawElement::MakeBox
(
OutDrawElements,
LayerId,
GradientAreaGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush("Checkerboard"),
MyClippingRect,
DrawEffects
);
}
// Draw the color gradient
FSlateDrawElement::MakeGradient
(
OutDrawElements,
LayerId,
GradientAreaGeometry.ToPaintGeometry(),
Stops,
Orient_Vertical,
MyClippingRect,
DrawEffects,
false
);
}
// Get actual editable stop marks
TArray<FGradientStopMark> ColorMarks;
TArray<FGradientStopMark> AlphaMarks;
GetGradientStopMarks( ColorMarks, AlphaMarks );
// Draw each color stop
for( int32 ColorIndex = 0; ColorIndex < ColorMarks.Num(); ++ColorIndex )
{
const FGradientStopMark& Mark = ColorMarks[ColorIndex];
float XVal = ScaleInfo.InputToLocalX( Mark.Time );
// Dont draw stops which are not visible
if( XVal >= 0 && XVal <= ColorMarkAreaGeometry.Size.X )
{
FLinearColor Color = CurveOwner->GetLinearColorValue( Mark.Time );
Color.A = 1.0f;
DrawGradientStopMark( Mark, ColorMarkAreaGeometry, XVal, Color, OutDrawElements, LayerId, MyClippingRect, DrawEffects, true, InWidgetStyle );
}
}
// Draw each alpha stop
for( int32 ColorIndex = 0; ColorIndex < AlphaMarks.Num(); ++ColorIndex )
{
const FGradientStopMark& Mark = AlphaMarks[ColorIndex];
float XVal = ScaleInfo.InputToLocalX( Mark.Time );
// Dont draw stops which are not visible
if( XVal >= 0 && XVal <= AlphaMarkAreaGeometry.Size.X )
{
float Alpha = CurveOwner->GetLinearColorValue( Mark.Time ).A;
DrawGradientStopMark( Mark, AlphaMarkAreaGeometry, XVal, FLinearColor( Alpha, Alpha, Alpha, 1.0f ), OutDrawElements, LayerId, MyClippingRect, DrawEffects, false, InWidgetStyle );
}
}
// Draw some hint messages about how to add stops if no stops exist
if( ColorMarks.Num() == 0 && AlphaMarks.Num() == 0 && IsEditingEnabled.Get() == true )
{
static FString GradientColorMessage( LOCTEXT("ClickToAddColorStop", "Click in this area add color stops").ToString() );
static FString GradientAlphaMessage( LOCTEXT("ClickToAddAlphaStop", "Click in this area add opacity stops").ToString() );
// Draw the text centered in the color region
{
FVector2D StringSize = FontMeasureService->Measure( GradientColorMessage, FSlateFontInfo( FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf"), 8 ) );
FPaintGeometry PaintGeom = ColorMarkAreaGeometry.ToPaintGeometry(FSlateLayoutTransform(FVector2D((ColorMarkAreaGeometry.Size.X - StringSize.X) * 0.5f, 1.0f)));
FSlateDrawElement::MakeText
(
OutDrawElements,
LayerId,
PaintGeom,
GradientColorMessage,
FSlateFontInfo( FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf"), 8 ),
MyClippingRect,
DrawEffects,
FLinearColor( .5f, .5f, .5f, .85f )
);
}
// Draw the text centered in the alpha region
{
FVector2D StringSize = FontMeasureService->Measure( GradientAlphaMessage, FSlateFontInfo( FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf"), 8 ) );
FPaintGeometry PaintGeom = AlphaMarkAreaGeometry.ToPaintGeometry(FSlateLayoutTransform(FVector2D((AlphaMarkAreaGeometry.Size.X - StringSize.X) * 0.5f, 1.0f)));
FSlateDrawElement::MakeText
(
OutDrawElements,
LayerId,
PaintGeom,
GradientAlphaMessage,
FSlateFontInfo( FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf"), 8 ),
MyClippingRect,
DrawEffects,
FLinearColor( .5f, .5f, .5f, .85f )
);
}
}
}
return LayerId;
}
void FBlueprintProfilerConnectionDrawingPolicy::DrawPerfConnection(int32 LayerId, const FVector2D& Start, const FVector2D& End, const FScriptPerfConnectionParams& Params)
{
const FVector2D& P0 = Start;
const FVector2D& P1 = End;
const FVector2D SplineTangent = ComputeSplineTangent(P0, P1);
const FVector2D P0Tangent = (Params.StartDirection == EGPD_Output) ? SplineTangent : -SplineTangent;
const FVector2D P1Tangent = (Params.EndDirection == EGPD_Input) ? SplineTangent : -SplineTangent;
if (Settings->bTreatSplinesLikePins)
{
// Distance to consider as an overlap
const float QueryDistanceTriggerThresholdSquared = FMath::Square(Settings->SplineHoverTolerance + Params.WireThickness * 0.5f);
// Distance to pass the bounding box cull test (may want to expand this later on if we want to do 'closest pin' actions that don't require an exact hit)
const float QueryDistanceToBoundingBoxSquared = QueryDistanceTriggerThresholdSquared;
bool bCloseToSpline = false;
{
// The curve will include the endpoints but can extend out of a tight bounds because of the tangents
// P0Tangent coefficient maximizes to 4/27 at a=1/3, and P1Tangent minimizes to -4/27 at a=2/3.
const float MaximumTangentContribution = 4.0f / 27.0f;
FBox2D Bounds(ForceInit);
Bounds += FVector2D(P0);
Bounds += FVector2D(P0 + MaximumTangentContribution * P0Tangent);
Bounds += FVector2D(P1);
Bounds += FVector2D(P1 - MaximumTangentContribution * P1Tangent);
bCloseToSpline = Bounds.ComputeSquaredDistanceToPoint(LocalMousePosition) < QueryDistanceToBoundingBoxSquared;
}
if (bCloseToSpline)
{
// Find the closest approach to the spline
FVector2D ClosestPoint(ForceInit);
float ClosestDistanceSquared = FLT_MAX;
const int32 NumStepsToTest = 16;
const float StepInterval = 1.0f / (float)NumStepsToTest;
FVector2D Point1 = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, 0.0f);
for (float TestAlpha = 0.0f; TestAlpha < 1.0f; TestAlpha += StepInterval)
{
const FVector2D Point2 = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, TestAlpha + StepInterval);
const FVector2D ClosestPointToSegment = FMath::ClosestPointOnSegment2D(LocalMousePosition, Point1, Point2);
const float DistanceSquared = (LocalMousePosition - ClosestPointToSegment).SizeSquared();
if (DistanceSquared < ClosestDistanceSquared)
{
ClosestDistanceSquared = DistanceSquared;
ClosestPoint = ClosestPointToSegment;
}
Point1 = Point2;
}
// Record the overlap
if (ClosestDistanceSquared < QueryDistanceTriggerThresholdSquared)
{
if (ClosestDistanceSquared < SplineOverlapResult.GetDistanceSquared())
{
const float SquaredDistToPin1 = (Params.AssociatedPin1 != nullptr) ? (P0 - ClosestPoint).SizeSquared() : FLT_MAX;
const float SquaredDistToPin2 = (Params.AssociatedPin2 != nullptr) ? (P1 - ClosestPoint).SizeSquared() : FLT_MAX;
SplineOverlapResult = FGraphSplineOverlapResult(Params.AssociatedPin1, Params.AssociatedPin2, ClosestDistanceSquared, SquaredDistToPin1, SquaredDistToPin2);
}
}
}
}
// Draw the spline itself
const float WireThickness = Params.WireThickness * ZoomFactor;
TArray<FSlateGradientStop> Gradients;
Gradients.Add(FSlateGradientStop(FVector2D::ZeroVector, Params.WireColor));
Gradients.Add(FSlateGradientStop(FVector2D::ZeroVector, Params.WireColor2));
FSlateDrawElement::MakeDrawSpaceGradientSpline(
DrawElementsList,
LayerId,
P0, P0Tangent,
P1, P1Tangent,
ClippingRect,
Gradients,
WireThickness,
ESlateDrawEffect::None);
if (Params.bDrawBubbles || (MidpointImage != nullptr))
{
// This table maps distance along curve to alpha
FInterpCurve<float> SplineReparamTable;
const float SplineLength = MakeSplineReparamTable(P0, P0Tangent, P1, P1Tangent, SplineReparamTable);
// Draw bubbles on the spline
if (Params.bDrawBubbles)
{
const float BubbleSpacing = 64.f * ZoomFactor;
const float BubbleSpeed = 192.f * ZoomFactor;
float Time = (FPlatformTime::Seconds() - GStartTime);
const float BubbleOffset = FMath::Fmod(Time * BubbleSpeed, BubbleSpacing);
const int32 NumBubbles = FMath::CeilToInt(SplineLength/BubbleSpacing);
const float SizeMin = WireThickness * 0.05f;
const float SizeScale = WireThickness * 0.10f;
const float SizeA = SizeMin + (Params.PerformanceData1 * SizeScale);
const float SizeB = SizeMin + (Params.PerformanceData2 * SizeScale);
for (int32 i = 0; i < NumBubbles; ++i)
{
const float Distance = ((float)i * BubbleSpacing) + BubbleOffset;
if (Distance < SplineLength)
{
const float Alpha = SplineReparamTable.Eval(Distance, 0.f);
FVector2D BubblePos = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, Alpha);
const FVector2D BubbleSize = BubbleImage->ImageSize * FMath::Lerp(SizeA, SizeB, Alpha);
const FLinearColor ElementColor = FLinearColor::LerpUsingHSV(Params.WireColor, Params.WireColor2, Alpha);
BubblePos -= (BubbleSize * 0.5f);
FSlateDrawElement::MakeBox(
DrawElementsList,
LayerId,
FPaintGeometry( BubblePos, BubbleSize, ZoomFactor ),
BubbleImage,
ClippingRect,
ESlateDrawEffect::None,
ElementColor
);
}
}
}
// Draw the midpoint image
if (MidpointImage != nullptr)
{
// Determine the spline position for the midpoint
const float MidpointAlpha = SplineReparamTable.Eval(SplineLength * 0.5f, 0.f);
const FVector2D Midpoint = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, MidpointAlpha);
// Approximate the slope at the midpoint (to orient the midpoint image to the spline)
const FVector2D MidpointPlusE = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, MidpointAlpha + KINDA_SMALL_NUMBER);
const FVector2D MidpointMinusE = FMath::CubicInterp(P0, P0Tangent, P1, P1Tangent, MidpointAlpha - KINDA_SMALL_NUMBER);
const FVector2D SlopeUnnormalized = MidpointPlusE - MidpointMinusE;
// Draw the arrow
const FVector2D MidpointDrawPos = Midpoint - MidpointRadius;
const float AngleInRadians = SlopeUnnormalized.IsNearlyZero() ? 0.0f : FMath::Atan2(SlopeUnnormalized.Y, SlopeUnnormalized.X);
FLinearColor ElementColor = FLinearColor::LerpUsingHSV(Params.WireColor, Params.WireColor2, 0.5f);
FSlateDrawElement::MakeRotatedBox(
DrawElementsList,
LayerId,
FPaintGeometry(MidpointDrawPos, MidpointImage->ImageSize * ZoomFactor, ZoomFactor),
MidpointImage,
ClippingRect,
ESlateDrawEffect::None,
AngleInRadians,
TOptional<FVector2D>(),
FSlateDrawElement::RelativeToElement,
ElementColor
);
}
}
}
int32 SColorBlock::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateBrush* GenericBrush = FCoreStyle::Get().GetBrush( "GenericWhiteBox" );
const ESlateDrawEffect::Type DrawEffects = ESlateDrawEffect::None;
FLinearColor InColor = Color.Get();
if (ColorIsHSV.Get())
{
InColor = InColor.HSVToLinearRGB();
}
if (IgnoreAlpha.Get())
{
InColor.A = 1.f;
}
const FColor DrawColor = InColor.ToFColor(bUseSRGB.Get());
if( ShowBackgroundForAlpha.Get() && DrawColor.A < 255 )
{
// If we are showing a background pattern and the colors is transparent, draw a checker pattern
const FSlateBrush* CheckerBrush = FCoreStyle::Get().GetBrush("ColorPicker.AlphaBackground");
FSlateDrawElement::MakeBox( OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), CheckerBrush, MyClippingRect, DrawEffects );
}
// determine if it is HDR
const float MaxRGB = FMath::Max3(InColor.R, InColor.G, InColor.B);
if (MaxRGB > 1.f)
{
FLinearColor NormalizedLinearColor = InColor / MaxRGB;
NormalizedLinearColor.A = InColor.A;
const FColor DrawNormalizedColor = InWidgetStyle.GetColorAndOpacityTint() * NormalizedLinearColor.ToFColor(bUseSRGB.Get());
FLinearColor ClampedLinearColor = InColor;
ClampedLinearColor.A = InColor.A * MaxRGB;
const FColor DrawClampedColor = InWidgetStyle.GetColorAndOpacityTint() * ClampedLinearColor.ToFColor(bUseSRGB.Get());
TArray<FSlateGradientStop> GradientStops;
GradientStops.Add( FSlateGradientStop( FVector2D::ZeroVector, DrawNormalizedColor ) );
GradientStops.Add( FSlateGradientStop( AllottedGeometry.Size * 0.5f, DrawClampedColor ) );
GradientStops.Add( FSlateGradientStop( AllottedGeometry.Size, DrawNormalizedColor ) );
FSlateDrawElement::MakeGradient(
OutDrawElements,
LayerId + 1,
AllottedGeometry.ToPaintGeometry(),
GradientStops,
(AllottedGeometry.Size.X > AllottedGeometry.Size.Y) ? Orient_Vertical : Orient_Horizontal,
MyClippingRect,
DrawEffects
);
}
else
{
FSlateDrawElement::MakeBox( OutDrawElements, LayerId + 1, AllottedGeometry.ToPaintGeometry(), GenericBrush, MyClippingRect, DrawEffects, InWidgetStyle.GetColorAndOpacityTint() * DrawColor );
}
return LayerId + 1;
}
