UWheelMenu Class Reference

#include <WheelMenu.h>

Inheritance diagram for UWheelMenu:

Public Member Functions
	UWheelMenu (const FObjectInitializer &ObjectInitializer)
virtual void	SetWheelData (const FRadialMenuData &Data) override
virtual bool	GetCurrentIndex (int32 &Value) const override
virtual void	StartUpdateInput () override
virtual void	CenterMousePosition () override
FVector2D	GetJoystickDirection (const bool bLeft) const

Protected Member Functions
virtual bool	Initialize () override
virtual void	NativePreConstruct () override
virtual void	NativeConstruct () override
virtual void	UpdateInput ()
void	SetIndex (const int32 Value)
FVector2D	FixInputRotation (const FVector2D &Input) const
void	SetInDeadZone (const bool bValue)
FVector2D	GetScreenCenter () const
float	GetSectionDegreeSize () const
float	GetSectionDegreeSizeUp () const
FVector	GetSegmentDirection (const int32 SegmentIndex) const
void	UpdateChildPositions () const
void	SetBackgroundRotation () const
void	UpdateDirectionWithMouseCursor ()
void	UpdateDirectionWithJoystick ()
void	SetInputDirection (const FVector2D Direction)

Protected Attributes
class UOverlay *	RootOverlay = nullptr
class UImage *	RadialBackground = nullptr
class UImage *	RadialDebug = nullptr
class UTextBlock *	TitleTextBlock = nullptr
class UTextBlock *	DescriptionTextBlock = nullptr
class USizeBox *	SizeBox = nullptr
float	UpdateSpeed = 1.0f
bool	bNormalize = false
float	ItemOffsetRadius = 180.0f
bool	bAutoRotateForUp = true
bool	bUseCustomInput = false
float	MouseDeadZone = 0.2f
float	JoystickDeadZone = 0.3f
UMaterialInterface *	MaterialBase = nullptr
FName	MaterialParamSegments = FName("Segments")
FName	MaterialParamIndex = FName("Index")
FName	MaterialParamDeadZone = FName("Deadzone")
FName	MaterialParamRadialTexture = FName("RadialTexture")
bool	bUseCustomTexture = false
UTexture2D *	RadialTexture = nullptr
bool	bUseCustomColors = false
FName	MaterialParamOuterRingColor = FName("OuterRingColor")
FName	MaterialParamInnerRingColor = FName("InnerRingColor")
FName	MaterialParamRingMainColor = FName("RingMainColor")
FName	MaterialParamUnhighlightColor = FName("UnhighlightColor")
FLinearColor	OuterRingColorDefault = FLinearColor(0.0f,0.25641f, 1.0f)
FLinearColor	InnerRingColorDefault = FLinearColor(0.369792f,0.369792f, 0.369792f)
FLinearColor	RingMainColorDefault = FLinearColor(1.0f,1.0f, 1.0f)
FLinearColor	UnhighlightColorDefault = FLinearColor(0.291667f, 0.291667f, 0.291667f)
FVector2D	MenuSizeDefault = FVector2D(512.0f, 512.0f)
bool	bUseDeadZoneEvents = false
float	IndexRaw = 0.0f
int32	Index = -1
int32	Segments = 2
bool	bInDeadZone = false
FVector2D	CurrentInput = FVector2D::ZeroVector
UMaterialInstanceDynamic *	DynamicMaterial = nullptr
FRadialMenuData	MenuData

Private Member Functions
virtual bool	GetCurrentSegmentData (FRadialSegmentData &Data) const
void	SetDescriptionText (const FRadialSegmentData &SegmentData) const
void	SetCancelText () const
void	ClearDescriptionText () const
void	SetColors (const FLinearColor &OuterRing, const FLinearColor &InnerRing, const FLinearColor &RingMain, const FLinearColor &UnHighlight)
void	SetColorsToDefault ()
void	SetMenuSize () const
void	CreateMaterial ()
void	UpdateMaterials () const
void	UpdateMaterialVisuals () const
void	SetMaterialSegments () const
void	Setup ()
void	SetSegmentData (const TArray< FRadialSegmentData > &Selections, const bool bShowDescription) const

Private Attributes
FTimerHandle	UpdateSpeedTimer
TSubclassOf< UUserWidget >	RadialSegmentClass
FLinearColor	OuterRingColor = FLinearColor(0.0f,0.25641f, 1.0f)
FLinearColor	InnerRingColor = FLinearColor(0.369792f,0.369792f, 0.369792f)
FLinearColor	RingMainColor = FLinearColor(1.0f,1.0f, 1.0f)
FLinearColor	UnhighlightColor = FLinearColor(0.291667f, 0.291667f, 0.291667f)

Constructor & Destructor Documentation

UWheelMenu()

UWheelMenu::UWheelMenu ( const FObjectInitializer & ObjectInitializer )

explicit

    : Super(ObjectInitializer)
{
    const ConstructorHelpers::FClassFinder<UWheelSegment> RadialWheelWidget(TEXT("/BaseHelpers/Widgets/WBP_WheelSegment"));
    if (!ensure(RadialWheelWidget.Class != nullptr)) return;
    RadialSegmentClass = RadialWheelWidget.Class;
}

Member Function Documentation

CenterMousePosition()

void UWheelMenu::CenterMousePosition ( )

overridevirtual

Implements IRadialMenu.

{
    GetOwningPlayer()->SetMouseLocation(GetScreenCenter().X, GetScreenCenter().Y);
    CurrentInput = FVector2D(GetScreenCenter().X, GetScreenCenter().Y);
}

ClearDescriptionText()

void UWheelMenu::ClearDescriptionText ( ) const

private

{
    if(TitleTextBlock == nullptr || DescriptionTextBlock == nullptr){return;}
    TitleTextBlock->SetText(FText::FromString(""));
    DescriptionTextBlock->SetText(FText::FromString(""));
}

CreateMaterial()

void UWheelMenu::CreateMaterial ( )

private

{
    DynamicMaterial = UKismetMaterialLibrary::CreateDynamicMaterialInstance(GetOwningPlayer(), MaterialBase);
}

FixInputRotation()

FVector2D UWheelMenu::FixInputRotation ( const FVector2D & Input ) const

protected

{
    if(bAutoRotateForUp)
    {
        const FVector Direction = UKismetMathLibrary::RotateAngleAxis(FVector(Input, 0.0f), (GetSectionDegreeSizeUp() * -1.0f), FVector(0.0f,0.0f,1.0f));
        return FVector2D(Direction);
    }
    return Input;
}

GetCurrentIndex()

bool UWheelMenu::GetCurrentIndex ( int32 & Value ) const

overridevirtual

Implements IRadialMenu.

{
    Value = Index;
    if(Index >= 0 && RootOverlay->GetAllChildren().IsValidIndex(Index))
    {
        return true;
    }
    return false;
}

GetCurrentSegmentData()

bool UWheelMenu::GetCurrentSegmentData ( FRadialSegmentData & Data ) const

privatevirtual

{
    FRadialSegmentData SegmentData;
    if(MenuData.Selections.IsValidIndex(Index) == false){return false;}
    Data = MenuData.Selections[Index];
    return true;
}

GetJoystickDirection()

FVector2D UWheelMenu::GetJoystickDirection

(

const bool

bLeft

)

const

{
    FVector2D Direction;
    if(GetOwningPlayer() == nullptr){return Direction;}
    const IPlayerControllerInterface* PlayerControllerInterface = Cast<IPlayerControllerInterface>(GetOwningPlayer());
    if(PlayerControllerInterface == nullptr){return Direction;}
    if(bLeft)
    {
        Direction = PlayerControllerInterface->GetMoveAxis();
        Direction.Y *= -1.0f;
    }
    else
    {
        Direction = PlayerControllerInterface->GetLookAxis();
    }
    return Direction;
}

GetScreenCenter()

FVector2D UWheelMenu::GetScreenCenter ( ) const

protected

{
    if(GetOwningPlayer() == nullptr){return FVector2D::ZeroVector;}
    const FVector2D ViewportSize = UWidgetLayoutLibrary::GetViewportSize(GetOwningPlayer());
    const int32 HalfWidth = UKismetMathLibrary::FTrunc(ViewportSize.X / 2.0f);
    const int32 HalfHeight = UKismetMathLibrary::FTrunc(ViewportSize.Y / 2.0f);
    return FVector2D(HalfWidth, HalfHeight);
}

GetSectionDegreeSize()

float UWheelMenu::GetSectionDegreeSize ( ) const

protected

{
    return 360.0f / static_cast<float>(Segments);
}

GetSectionDegreeSizeUp()

float UWheelMenu::GetSectionDegreeSizeUp ( ) const

protected

{
    return (GetSectionDegreeSize() / 2.0f * -1.0f);
}

GetSegmentDirection()

FVector UWheelMenu::GetSegmentDirection ( const int32 SegmentIndex ) const

protected

{
    const float Center = (static_cast<float>(SegmentIndex) + 0.5f);
    const float Angle = Center * GetSectionDegreeSize();
    FVector Direction = UKismetMathLibrary::RotateAngleAxis(FVector(0.0f, -1.0f, 0.0f), Angle, FVector(0.0f,0.0f,1.0f));
    if(bAutoRotateForUp)
    {
        const float UpAngle = GetSectionDegreeSizeUp();
        Direction = UKismetMathLibrary::RotateAngleAxis(Direction, UpAngle, FVector(0.0f, 0.0f, 1.0f));
    }
    return Direction;
}

Initialize()

bool UWheelMenu::Initialize ( )

overrideprotectedvirtual

{
    const bool Success = Super::Initialize();
    if(!Success) return false;
    if (!ensure(RadialDebug != nullptr)) return false;
    if (!ensure(RadialBackground != nullptr)) return false;
    if (!ensure(RootOverlay != nullptr)) return false;
    if (!ensure(RadialSegmentClass != nullptr)) return false;
    if (!ensure(TitleTextBlock != nullptr)) return false;
    if (!ensure(DescriptionTextBlock != nullptr)) return false;
    if (!ensure(SizeBox != nullptr)) return false;
    return true;
}

NativeConstruct()

void UWheelMenu::NativeConstruct ( )

overrideprotectedvirtual

{
    Super::NativeConstruct();
    Setup();
}

NativePreConstruct()

void UWheelMenu::NativePreConstruct ( )

overrideprotectedvirtual

{
    Super::NativePreConstruct();
    if(RadialDebug != nullptr)
    {
        RadialDebug->SetRenderTranslation(FVector2D(0.0f, ItemOffsetRadius));
    }
    Setup();
}

SetBackgroundRotation()

void UWheelMenu::SetBackgroundRotation ( ) const

protected

{
    float Angle = 0.0f;
    if(bAutoRotateForUp)
    {
        Angle = GetSectionDegreeSizeUp();
    }
    RadialBackground->SetRenderTransformAngle(Angle);
}

SetCancelText()

void UWheelMenu::SetCancelText ( ) const

private

{
    TitleTextBlock->SetText(FText::FromString("Cancel"));
    DescriptionTextBlock->SetText(FText::FromString(""));
}

SetColors()

void UWheelMenu::SetColors ( const FLinearColor & OuterRing, const FLinearColor & InnerRing, const FLinearColor & RingMain, const FLinearColor & UnHighlight )

private

{
    OuterRingColor = OuterRing;
    InnerRingColor = InnerRing;
    RingMainColor = RingMain;
    UnhighlightColor = UnHighlight;
}

SetColorsToDefault()

void UWheelMenu::SetColorsToDefault ( )

private

{
    SetColors(OuterRingColorDefault, InnerRingColorDefault, RingMainColorDefault, UnhighlightColorDefault);
}

SetDescriptionText()

void UWheelMenu::SetDescriptionText ( const FRadialSegmentData & SegmentData ) const

private

{
    if(TitleTextBlock == nullptr || DescriptionTextBlock == nullptr){return;}
    if(SegmentData.IsValid() == false){SetCancelText();return;}
    if(SegmentData.Name.IsEmpty())
    {
        TitleTextBlock->SetVisibility(ESlateVisibility::Collapsed);
    }
    else
    {
        TitleTextBlock->SetVisibility(ESlateVisibility::Visible);
    }
    if(SegmentData.Description.IsEmpty())
    
    {
        DescriptionTextBlock->SetVisibility(ESlateVisibility::Collapsed);
    }
    else
    {
        DescriptionTextBlock->SetVisibility(ESlateVisibility::Visible);
    }
    TitleTextBlock->SetText(FText::FromString(SegmentData.Name));
    DescriptionTextBlock->SetText(FText::FromString(SegmentData.Description));
}

SetInDeadZone()

void UWheelMenu::SetInDeadZone ( const bool bValue )

protected

{
    if(bInDeadZone == bValue){return;}
    bInDeadZone = bValue;
    if(bInDeadZone)
    {
        SetIndex(-1);
    }
    if(bUseDeadZoneEvents)
    {
        // OnDeadZoneChanged(const bool bValue);
        
    }
    UpdateMaterials();
}

SetIndex()

void UWheelMenu::SetIndex ( const int32 Value )

protected

{
    if(Index == Value){return;}
    Index = Value;
    if(RootOverlay->GetAllChildren().IsValidIndex(Index))
    {
        UWheelSegment* LastSelection = Cast<UWheelSegment>(RootOverlay->GetAllChildren()[Index]);
        if(LastSelection != nullptr)
        {
            LastSelection->SetSelected(false);
        }
    }
    FRadialSegmentData SelectedSegmentData;
    if(RootOverlay->GetAllChildren().IsValidIndex(Index))
    {
        UWheelSegment* NextSelection = Cast<UWheelSegment>(RootOverlay->GetAllChildren()[Index]);
        if(NextSelection != nullptr)
        {
            NextSelection->SetSelected(true);
            SelectedSegmentData = NextSelection->GetSegmentData();
        }
    }
    if(MenuData.bCenterDescription)
    {
        SetDescriptionText(SelectedSegmentData);
    }
    else
    {
        ClearDescriptionText();
    }
    //Call OnSelectionChanged(const int32 NewSelection, const int32 PreviousSelection);
}

SetInputDirection()

void UWheelMenu::SetInputDirection ( const FVector2D Direction )

protected

{
    CurrentInput = FixInputRotation(Direction);
    FVector2D Input = CurrentInput;
    UKismetMathLibrary::Normalize2D(Input);
    const float Degrees = UKismetMathLibrary::DegAtan2(Input.X * -1.0f, Input.Y);
    const float DegreesWithOffset = Degrees + 180.0f; //Offset the input so 0 index is on the top right.
    IndexRaw = DegreesWithOffset / GetSectionDegreeSize();
    const int32 IndexToSet = UKismetMathLibrary::FTrunc(IndexRaw);
    SetIndex(IndexToSet);
    UpdateMaterials();
}

SetMaterialSegments()

void UWheelMenu::SetMaterialSegments ( ) const

private

{
    if(DynamicMaterial == nullptr){return;}
    DynamicMaterial->SetScalarParameterValue(MaterialParamSegments, static_cast<float>(Segments));
}

SetMenuSize()

void UWheelMenu::SetMenuSize ( ) const

private

{
    if(SizeBox != nullptr)
    {
        if(MenuData.bUseCustomSize)
        {
            SizeBox->SetWidthOverride(MenuData.MenuSize.X);
            SizeBox->SetHeightOverride(MenuData.MenuSize.Y);
            return;
        }
        SizeBox->SetWidthOverride(MenuSizeDefault.X);
        SizeBox->SetHeightOverride(MenuSizeDefault.Y);
    }
}

SetSegmentData()

void UWheelMenu::SetSegmentData ( const TArray< FRadialSegmentData > & Selections, const bool bShowDescription ) const

private

{
    for(int i = 0; i < Selections.Num(); ++i)
    {
        UWheelSegment* WheelSegment = CreateWidget<UWheelSegment>(GetOwningPlayer(), RadialSegmentClass);
        WheelSegment->SetShowDescription(bShowDescription);
        WheelSegment->SetSegmentData(Selections[i]);
        WheelSegment->SetIndex(i);
        UPanelSlot* Panel = RootOverlay->AddChild(WheelSegment);
        if(Panel != nullptr)
        {
            UOverlaySlot* OverlaySlot = Cast<UOverlaySlot>(Panel);
            if(OverlaySlot != nullptr)
            {
                OverlaySlot->SetVerticalAlignment(VAlign_Center);
                OverlaySlot->SetHorizontalAlignment(HAlign_Center);
                WheelSegment->SetRenderTransformPivot(FVector2D(0.5f, 0.5f));
            }
        }
    }
}

Setup()

void UWheelMenu::Setup ( )

private

{
    CreateMaterial();
    if(DynamicMaterial != nullptr && RadialBackground != nullptr)
    {
        RadialBackground->SetBrushFromMaterial(DynamicMaterial);
        SetMaterialSegments();
        SetBackgroundRotation();
        UpdateMaterialVisuals();
    }
    SetMenuSize();
}

SetWheelData()

void UWheelMenu::SetWheelData ( const FRadialMenuData & Data )

overridevirtual

Implements IRadialMenu.

{
    MenuData = Data;
    Segments = 0;
    SetIndex(-1);
    RootOverlay->ClearChildren();
    ClearDescriptionText();
    SetCancelText();
    bUseCustomColors = MenuData.bUseCustomColors;
    if(MenuData.bUseCustomColors)
    {
        SetColors(Data.OuterRingColor, Data.InnerRingColor, Data.RingMainColor, Data.UnhighlightColor);
    }
    else
    {
        SetColorsToDefault();
    }
    SetSegmentData(MenuData.Selections, MenuData.bShowSegmentDescription);
    Segments = RootOverlay->GetChildrenCount();
    UpdateChildPositions();
    SetMaterialSegments();
    SetBackgroundRotation();
    UpdateMaterialVisuals();
    UpdateMaterials();
    SetMenuSize();
}

StartUpdateInput()

void UWheelMenu::StartUpdateInput ( )

overridevirtual

Implements IRadialMenu.

{
    GetWorld()->GetTimerManager().SetTimer(UpdateSpeedTimer, this, &UWheelMenu::UpdateInput, UpdateSpeed, true);
}

UpdateChildPositions()

void UWheelMenu::UpdateChildPositions ( ) const

protected

{
    TArray<UWidget*> AllSegments = RootOverlay->GetAllChildren();
    for (int i = 0; i < RootOverlay->GetChildrenCount(); ++i)
    {
        if(AllSegments.IsValidIndex(i) == false){continue;}
        const FVector Direction = (GetSegmentDirection(i) * ItemOffsetRadius);
        AllSegments[i]->SetRenderTranslation(FVector2D(Direction));
    }
}

UpdateDirectionWithJoystick()

void UWheelMenu::UpdateDirectionWithJoystick ( )

protected

{
    if(GetOwningPlayer() == nullptr){return;}
    const FVector2D Direction = GetJoystickDirection(MenuData.bLeftJoystick);
    if(UKismetMathLibrary::VSize2D(Direction) <= JoystickDeadZone)
    {
        CurrentInput = FVector2D::ZeroVector;
    }
    else
    {
        SetInputDirection(Direction);
    }
}

UpdateDirectionWithMouseCursor()

void UWheelMenu::UpdateDirectionWithMouseCursor ( )

protected

{
    const FVector2D MousePosition = UWidgetLayoutLibrary::GetMousePositionOnViewport(GetOwningPlayer());
    const float ViewportScale = UWidgetLayoutLibrary::GetViewportScale(GetOwningPlayer());
    const FVector2D ScaledMousePosition = (MousePosition * ViewportScale) - (GetScreenCenter());
    FVector2D ModifiedMousePosition = FVector2D(ScaledMousePosition.X, ScaledMousePosition.Y);
     if(ModifiedMousePosition.Length() <= (ViewportScale * MouseDeadZone))
     {
        CurrentInput = FVector2D::ZeroVector;
        return;
     }
    if(bNormalize)
    {
        UKismetMathLibrary::Normalize2D(ModifiedMousePosition);
    }
    RadialDebug->SetRenderTranslation(ModifiedMousePosition);
    // @ Should this be somewhere else?
    SetInputDirection(ModifiedMousePosition);
}

UpdateInput()

void UWheelMenu::UpdateInput ( )

protectedvirtual

{
    if(bUseCustomInput)
    {
        //UpdateDirectionWithCustomInput
    }
    UpdateDirectionWithJoystick();
    if(UKismetMathLibrary::VSize2D(CurrentInput) <= JoystickDeadZone)
    {
        UpdateDirectionWithMouseCursor();
        SetInDeadZone(CurrentInput.Length() <= JoystickDeadZone);
        return;
    }
    SetInDeadZone(false);
}

UpdateMaterials()

void UWheelMenu::UpdateMaterials ( ) const

private

{
    if(DynamicMaterial == nullptr){return;}
    DynamicMaterial->SetScalarParameterValue(MaterialParamIndex, IndexRaw);
    DynamicMaterial->SetScalarParameterValue(MaterialParamDeadZone, bInDeadZone);
}

UpdateMaterialVisuals()

void UWheelMenu::UpdateMaterialVisuals ( ) const

private

{
    if(DynamicMaterial == nullptr){return;}
    if(bUseCustomTexture && RadialTexture != nullptr)
    {
        DynamicMaterial->SetTextureParameterValue(MaterialParamRadialTexture, RadialTexture);
    }
    if(bUseCustomColors)
    {
        DynamicMaterial->SetVectorParameterValue(MaterialParamOuterRingColor, OuterRingColor);
        DynamicMaterial->SetVectorParameterValue(MaterialParamInnerRingColor, InnerRingColor);
        DynamicMaterial->SetVectorParameterValue(MaterialParamRingMainColor, RingMainColor);
        DynamicMaterial->SetVectorParameterValue(MaterialParamUnhighlightColor, UnhighlightColor);
    }
}

Member Data Documentation

bAutoRotateForUp

bool UWheelMenu::bAutoRotateForUp = true

protected

Have a main Slice at the top

bInDeadZone

bool UWheelMenu::bInDeadZone = false

protected

bNormalize

bool UWheelMenu::bNormalize = false

protected

bUseCustomColors

bool UWheelMenu::bUseCustomColors = false

protected

bUseCustomInput

bool UWheelMenu::bUseCustomInput = false

protected

bUseCustomTexture

bool UWheelMenu::bUseCustomTexture = false

protected

bUseDeadZoneEvents

bool UWheelMenu::bUseDeadZoneEvents = false

protected

CurrentInput

FVector2D UWheelMenu::CurrentInput = FVector2D::ZeroVector

protected

DescriptionTextBlock

class UTextBlock* UWheelMenu::DescriptionTextBlock = nullptr

protected

DynamicMaterial

UMaterialInstanceDynamic* UWheelMenu::DynamicMaterial = nullptr

protected

Index

int32 UWheelMenu::Index = -1

protected

The current truncated index of the user's selection

IndexRaw

float UWheelMenu::IndexRaw = 0.0f

protected

Raw index is useful for converting back to a direction and getting in between values.

InnerRingColor

FLinearColor UWheelMenu::InnerRingColor = FLinearColor(0.369792f,0.369792f, 0.369792f)

private

InnerRingColorDefault

FLinearColor UWheelMenu::InnerRingColorDefault = FLinearColor(0.369792f,0.369792f, 0.369792f)

protected

ItemOffsetRadius

float UWheelMenu::ItemOffsetRadius = 180.0f

protected

How far from the center should the widgets be placed? NOTE: The square seen in the viewport is there to debug this,

JoystickDeadZone

float UWheelMenu::JoystickDeadZone = 0.3f

protected

How far should the stick be pressed before being used as input.

MaterialBase

UMaterialInterface* UWheelMenu::MaterialBase = nullptr

protected

MaterialParamDeadZone

FName UWheelMenu::MaterialParamDeadZone = FName("Deadzone")

protected

MaterialParamIndex

FName UWheelMenu::MaterialParamIndex = FName("Index")

protected

MaterialParamInnerRingColor

FName UWheelMenu::MaterialParamInnerRingColor = FName("InnerRingColor")

protected

MaterialParamOuterRingColor

FName UWheelMenu::MaterialParamOuterRingColor = FName("OuterRingColor")

protected

MaterialParamRadialTexture

FName UWheelMenu::MaterialParamRadialTexture = FName("RadialTexture")

protected

MaterialParamRingMainColor

FName UWheelMenu::MaterialParamRingMainColor = FName("RingMainColor")

protected

MaterialParamSegments

FName UWheelMenu::MaterialParamSegments = FName("Segments")

protected

MaterialParamUnhighlightColor

FName UWheelMenu::MaterialParamUnhighlightColor = FName("UnhighlightColor")

protected

MenuData

FRadialMenuData UWheelMenu::MenuData

protected

MenuSizeDefault

FVector2D UWheelMenu::MenuSizeDefault = FVector2D(512.0f, 512.0f)

protected

MouseDeadZone

float UWheelMenu::MouseDeadZone = 0.2f

protected

OuterRingColor

FLinearColor UWheelMenu::OuterRingColor = FLinearColor(0.0f,0.25641f, 1.0f)

private

OuterRingColorDefault

FLinearColor UWheelMenu::OuterRingColorDefault = FLinearColor(0.0f,0.25641f, 1.0f)

protected

RadialBackground

class UImage* UWheelMenu::RadialBackground = nullptr

protected

RadialDebug

class UImage* UWheelMenu::RadialDebug = nullptr

protected

RadialSegmentClass

TSubclassOf<UUserWidget> UWheelMenu::RadialSegmentClass

private

RadialTexture

UTexture2D* UWheelMenu::RadialTexture = nullptr

protected

RingMainColor

FLinearColor UWheelMenu::RingMainColor = FLinearColor(1.0f,1.0f, 1.0f)

private

RingMainColorDefault

FLinearColor UWheelMenu::RingMainColorDefault = FLinearColor(1.0f,1.0f, 1.0f)

protected

RootOverlay

class UOverlay* UWheelMenu::RootOverlay = nullptr

protected

Segments

int32 UWheelMenu::Segments = 2

protected

SizeBox

class USizeBox* UWheelMenu::SizeBox = nullptr

protected

TitleTextBlock

class UTextBlock* UWheelMenu::TitleTextBlock = nullptr

protected

UnhighlightColor

FLinearColor UWheelMenu::UnhighlightColor = FLinearColor(0.291667f, 0.291667f, 0.291667f)

private

UnhighlightColorDefault

FLinearColor UWheelMenu::UnhighlightColorDefault = FLinearColor(0.291667f, 0.291667f, 0.291667f)

protected

UpdateSpeed

float UWheelMenu::UpdateSpeed = 1.0f

protected

UpdateSpeedTimer

FTimerHandle UWheelMenu::UpdateSpeedTimer

private

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/Widgets/WheelMenu.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/Widgets/WheelMenu.cpp