RadarChartWidget.cpp

#include "RadarChartWidget.h"

void URadarChartWidget::PostLoad()
{
    Super::PostLoad();

    SyncEditorData();
}

#if WITH_EDITOR
void URadarChartWidget::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
    Super::PostEditChangeProperty(PropertyChangedEvent);

    const FName PropertyName = PropertyChangedEvent.Property
        ? PropertyChangedEvent.Property->GetFName()
        : NAME_None;

    bool bIsNumAxesChanged = PropertyName == GET_MEMBER_NAME_CHECKED(URadarChartWidget, NumAxes);
    bool bIsValuesMapLengthChanged = AxesValuesMap.Num() != NumAxes;
    if (bIsNumAxesChanged || bIsValuesMapLengthChanged)
    {
        SyncEditorData();
    }
}
#endif

void URadarChartWidget::SyncEditorData()
{
    // update axis names
    int32 OldSize = AxesOrderFromTop.Num();
    AxesOrderFromTop.SetNum(NumAxes);
    for (int32 i = OldSize; i < NumAxes; i++)
    {
        FName AxisName = FName(FString::Printf(TEXT("axis%i"), i + 1));
        AxesOrderFromTop[i] = AxisName;
    }

    // update values map
    TMap<FName, float> NewMap;
    for (const FName& Axis : AxesOrderFromTop)
    {
        if (AxesValuesMap.Contains(Axis))
        {
            NewMap.Add(Axis, AxesValuesMap[Axis]);
        }
        else
        {
            NewMap.Add(Axis, FMath::RandRange(0.5f, 1.f));
        }
    }
    AxesValuesMap = MoveTemp(NewMap);

    // recalculate angles for new polygon
    constexpr float StartAngle = -PI / 2.f;
    AxisDirections.Empty();
    for (int32 i = 0; i < NumAxes; ++i)
    {
        float Angle = StartAngle + i * (2 * PI / NumAxes);
        AxisDirections.Add(
            FVector2f(FMath::Cos(Angle), FMath::Sin(Angle))
        );
    }
}

void URadarChartWidget::SetAxisValue(const FName& AxisName, float Value)
{
    if (!AxesValuesMap.Contains(AxisName)) {
        UE_LOG(LogTemp, Error, TEXT("[RadarChartWidget::SetAxisValue] Axis '%s' doesnt exist!"), *AxisName.ToString());
        return;
    }
    float AxisValue = AxesValuesMap[AxisName];
    AxisValue = FMath::Clamp(AxisValue + Value, 0, 1);
    AxesValuesMap[AxisName] = AxisValue;
}

void URadarChartWidget::StartFilledPolygonAnimation(const TMap<FName, float>& AxesDiff)
{
    StartValuesMap = AxesValuesMap;

    DiffValuesMap.Empty();
    for (const auto& Pair : AxesDiff)
    {
        if (AxesValuesMap.Contains(Pair.Key))
        {
            DiffValuesMap.Add(Pair);
        }
    }

    AnimElapsed = 0.f;
    bAnimating = true;
}

void URadarChartWidget::NativeTick(const FGeometry& MyGeometry, float InDeltaTime)
{
    Super::NativeTick(MyGeometry, InDeltaTime);

    if (!bAnimating)
        return;

    AnimElapsed += InDeltaTime;
    float Alpha = FMath::Clamp(AnimElapsed / AnimDuration, 0.f, 1.f);

    for (const auto& Pair : DiffValuesMap)
    {
        float Start = StartValuesMap[Pair.Key];
        AxesValuesMap[Pair.Key] = Start + Pair.Value * Alpha;
    }

    if (Alpha >= 1.f)
    {
        bAnimating = false;
    }

    Invalidate(EInvalidateWidgetReason::Paint);
}

int32 URadarChartWidget::NativePaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
    Super::NativePaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);

    if (NumAxes == 0)
        return LayerId;

    if (bDrawFilledPolygon)
    {
        DrawFilledPolygon(AllottedGeometry, OutDrawElements, LayerId, InWidgetStyle);
        DrawFilledPolygonOutline(AllottedGeometry, OutDrawElements, LayerId + 1, InWidgetStyle);
    }
    else
    {
        DrawRadarChart(AllottedGeometry, OutDrawElements, LayerId);
    }
    return LayerId;
}

void URadarChartWidget::DrawWiredPolygon(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId, float Scale) const
{
    TArray<FVector2f> PolygonPointsLocal;
    PolygonPointsLocal.Reserve(NumAxes);

    const FVector2f Size = AllottedGeometry.GetLocalSize();
    const FVector2f Center = Size * 0.5f;
    const float Radius = FMath::Min(Size.X, Size.Y) * 0.5f;

    for (const FVector2f& Dir : AxisDirections)
    {
        PolygonPointsLocal.Add(Center + Dir * Radius * Scale);
    }
    PolygonPointsLocal.Add(FVector2f(PolygonPointsLocal[0]));

    FSlateDrawElement::MakeLines(
        OutDrawElements,
        LayerId,
        AllottedGeometry.ToPaintGeometry(),
        PolygonPointsLocal,
        ESlateDrawEffect::None,
        OutlineColor,
        true,
        OutlineThickness
    );
}

void URadarChartWidget::DrawAxes(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId) const
{
    TArray<FVector2f> AxisLinePointsLocal;
    AxisLinePointsLocal.Reserve(2);

    const FVector2f Size = AllottedGeometry.GetLocalSize();
    const FVector2f Center = Size * 0.5f;
    const float Radius = FMath::Min(Size.X, Size.Y) * 0.5f;

    for (const FVector2f& Dir : AxisDirections)
    {
        AxisLinePointsLocal.Add(Center);
        AxisLinePointsLocal.Add(Center + Dir * Radius);

        FSlateDrawElement::MakeLines(
            OutDrawElements,
            LayerId,
            AllottedGeometry.ToPaintGeometry(),
            AxisLinePointsLocal,
            ESlateDrawEffect::None,
            OutlineColor,
            true,
            OutlineThickness
        );

        AxisLinePointsLocal.Empty();
    }
}

void URadarChartWidget::DrawFilledPolygon(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle) const
{
    FLinearColor LinearColor = GetColorAndOpacity() * InWidgetStyle.GetColorAndOpacityTint() * Brush.GetTint(InWidgetStyle);
    FColor FinalColorAndOpacity = LinearColor.ToFColor(true);

    TArray<FVector2f> Points;
    Points.Reserve(NumAxes);

    const FVector2f Size = AllottedGeometry.GetLocalSize();
    const FVector2f Center = Size * 0.5f;
    const float Radius = FMath::Min(Size.X, Size.Y) * 0.5f;

    for (int32 i = 0; i < NumAxes; ++i)
    {
        const FName& AxisName = AxesOrderFromTop[i];
        FVector2f Dir = AxisDirections[i];
        Points.Add(Center + Dir * Radius * GetAxisValue(AxisName));
    }

    TArray<FSlateVertex> Vertices;
    TArray<SlateIndex> Indices;

    // Vertex at center
    {
        Vertices.Add(FSlateVertex::Make<ESlateVertexRounding::Disabled>(
            AllottedGeometry.GetAccumulatedRenderTransform(),
            Center,
            FVector2f(0.0f, 0.0f),
            FinalColorAndOpacity
        ));
    }

    // Outer vertices
    for (const FVector2f& P : Points)
    {
        Vertices.Add(FSlateVertex::Make<ESlateVertexRounding::Disabled>(
            AllottedGeometry.GetAccumulatedRenderTransform(),
            P,
            FVector2f(0.0f, 0.0f),
            FinalColorAndOpacity
        ));
    }

    // Build triangle fan
    for (int32 i = 1; i < Points.Num(); ++i)
    {
        Indices.Add(0);
        Indices.Add(i);
        Indices.Add(i + 1);
    }

    // Close fan
    Indices.Add(0);
    Indices.Add(Points.Num());
    Indices.Add(1);

    const FSlateResourceHandle Handle = FSlateApplication::Get().GetRenderer()->GetResourceHandle(Brush);
    FSlateDrawElement::MakeCustomVerts(
        OutDrawElements,
        LayerId,
        Handle,
        Vertices,
        Indices,
        nullptr,
        0,
        0
    );
}

void URadarChartWidget::DrawFilledPolygonOutline(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle) const
{
    TArray<FVector2f> PolygonPointsLocal;
    PolygonPointsLocal.Reserve(NumAxes);

    const FVector2f Size = AllottedGeometry.GetLocalSize();
    const FVector2f Center = Size * 0.5f;
    const float Radius = FMath::Min(Size.X, Size.Y) * 0.5f;

    float DotRadius = DotBrush.GetImageSize().X * 0.5f;
    FLinearColor DotLinearColor = GetColorAndOpacity() * InWidgetStyle.GetColorAndOpacityTint() * DotBrush.GetTint(InWidgetStyle);

    for (int32 i = 0; i < NumAxes; ++i)
    {
        const FName& AxisName = AxesOrderFromTop[i];
        FVector2f Dir = AxisDirections[i];
        FVector2f Point = Center + Dir * Radius * GetAxisValue(AxisName);
        PolygonPointsLocal.Add(Point);

        FSlateDrawElement::MakeBox(
            OutDrawElements,
            LayerId + 1,
            AllottedGeometry.ToPaintGeometry(
                FVector2f(Point - FVector2f(DotRadius)),
                FVector2f(DotRadius * 2.f)
            ),
            &DotBrush,
            ESlateDrawEffect::None,
            DotLinearColor
        );
    }
    PolygonPointsLocal.Add(FVector2f(PolygonPointsLocal[0]));

    FSlateDrawElement::MakeLines(
        OutDrawElements,
        LayerId,
        AllottedGeometry.ToPaintGeometry(),
        PolygonPointsLocal,
        ESlateDrawEffect::None,
        FilledOutlineColor,
        true,
        OutlineThickness
    );
}

void URadarChartWidget::DrawRadarChart(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId) const
{
    DrawWiredPolygon(AllottedGeometry, OutDrawElements, LayerId + 1, 1);
    if (bDrawValueMarks)
    {
        for (float Mark = MarkingStep; 
            Mark <= 1.f - MarkingStep || FMath::IsNearlyEqual(Mark, 1.f - MarkingStep, 0.01f); 
            Mark += MarkingStep)
        {
            DrawWiredPolygon(AllottedGeometry, OutDrawElements, LayerId, Mark);
        }
    }
    DrawAxes(AllottedGeometry, OutDrawElements, LayerId);
}

float URadarChartWidget::GetAxisValue(const FName& Axis) const
{
    return FMath::Clamp(AxesValuesMap[Axis], 0.f, 1.f);
}