PixoVRWristMenu.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "CharacterTools/PixoVRWristMenu.h"
#include "PixoVRCharacter.h"
#include "Components/StaticMeshComponent.h"
#include "Components/WidgetComponent.h"
#include "Components/SceneComponent.h"
#include "Components/ArrowComponent.h"
#include "Components/AudioComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetMathLibrary.h"
#include "Materials/MaterialInstance.h"
#include "UI/WristMenu/PixoVRWristMenuItemWidget.h"
#include "UI/WristMenu/PixoVRWristMenuItemTitleWidget.h"
#include "Interfaces/PixoVRWristMenuInterface.h"
#include "Sound/SoundCue.h"
 
DEFINE_LOG_CATEGORY(LogPixoVRWristMenu);
 
APixoVRWristMenu::APixoVRWristMenu()
    : RadialFloatingMesh(nullptr)
    , RadialArrowMesh(nullptr)
    , TimelineComponent(nullptr)
    , bIsActivated(false)
    , ThumbDeadZone(0.5f)
    , CurrentNormalAngleIndex(-1)
    , CurrentLargeAngleIndex(-1)
    , PreviousNormalAngleIndex(-1)
    , PreviousLargeAngleIndex(-1)
    , AnglePerNormalItem(0.0f)
    , AnglePerLargeItem(0.0f)
    , CurrentAngle(0.0f)
    , IconRadialDistance(7.0f)
    , IconRelativeScale(FVector(1.0f / 25.0f))
    , CurrentPadDirection(FVector2D::ZeroVector)
    , CurrentArrowRotation(FRotator::ZeroRotator)
    , WidgetDataTableDefault(nullptr)
    , WidgetDataTable(nullptr)
    , Title(nullptr)
    , CurrentPointedWidgetComponent(nullptr)
    , CurrentLargePointedWidgetComponent(nullptr)
    , RotationSpeed(1000.0f)
    , bAlignToPlayerHead(false)
    , MaxNumberOfNormalButtons(8)
    , MaxNumberOfLargeButtons(6)
{
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
 
    bReplicates = true;
    AActor::SetReplicateMovement(true);
 
    static ConstructorHelpers::FObjectFinder<USoundCue> SelectSoundCueFinder(TEXT("SoundCue'/PixoCore/Audio/SFX/PixoVR_UI_Menu_select_Cue.PixoVR_UI_Menu_Select_Cue'"));
    SelectAudioCue = SelectSoundCueFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<USoundCue> HoverSoundCueFinder(TEXT("SoundCue'/PixoCore/Audio/SFX/PixoVR_UI_Hover_Cue.PixoVR_UI_Hover_Cue'"));
    HoverAudioCue = HoverSoundCueFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> WristMenuMeshFinder(TEXT("StaticMesh'/PixoCore/WristMenu/SM_Radial_Disk.SM_Radial_Disk'"));
    UStaticMesh* WristMenuMesh = WristMenuMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UMaterialInstance> WristMenuMeshMaterialFinder(TEXT("MaterialInstanceConstant'/PixoCore/WristMenu/DiscMaterial.DiscMaterial'"));
    UMaterialInstance* WristMenuMeshMaterial = WristMenuMeshMaterialFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> WristMenuArrowMeshFinder(TEXT("StaticMesh'/PixoCore/WristMenu/SM_Radial_Pointer.SM_Radial_Pointer'"));
    UStaticMesh* WristMenuArrowMesh = WristMenuArrowMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UMaterial> WristMenuArrowMaterialFinder(TEXT("Material'/PixoCore/WristMenu/ArrowMaterial.ArrowMaterial'"));
    UMaterial* WristMenuArrowMaterial = WristMenuArrowMaterialFinder.Object;
 
    static ConstructorHelpers::FClassFinder<UUserWidget> WristMenuWidget(TEXT("/PixoCore/WristMenu/PixoVRWristMenuWidget"));
    WristMenuWidgetClass = WristMenuWidget.Class;
 
    static ConstructorHelpers::FClassFinder<UUserWidget> WristMenuTitleWidget(TEXT("/PixoCore/WristMenu/PixoVRWristMenuTitleWidget"));
    WristMenuTitleWidgetClass = WristMenuTitleWidget.Class;
 
    SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("WristMenuSceneComponent"));
    RootComponent = SceneComponent;
 
    RadialFloatingMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("WristMenuMesh"));
    RadialFloatingMesh->SetupAttachment(SceneComponent);
    RadialFloatingMesh->SetStaticMesh(WristMenuMesh);
    RadialFloatingMesh->SetMaterial(0, WristMenuMeshMaterial);
    RadialFloatingMesh->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    RadialFloatingMesh->SetGenerateOverlapEvents(false);
    RadialFloatingMesh->SetAbsolute(false, true, false);
 
    RadialArrowMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("WristMenuRadialArrowMesh"));
    RadialArrowMesh->SetupAttachment(RadialFloatingMesh);
    RadialArrowMesh->SetStaticMesh(WristMenuArrowMesh);
    RadialArrowMesh->SetMaterial(0, WristMenuArrowMaterial);
    RadialArrowMesh->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
 
    AudioComponent = CreateDefaultSubobject<UAudioComponent>(TEXT("AudioComponent"));
 
    TimelineComponent = CreateDefaultSubobject<UTimelineComponent>(TEXT("TimelineComponent"));
    TimelinePostUpdate.BindDynamic(this, &APixoVRWristMenu::HandleTimeLineFloat);
    TimelineFinished.BindDynamic(this, &APixoVRWristMenu::HandleTimelineFinished);
 
    AActor::SetActorHiddenInGame(true);
}
 
void APixoVRWristMenu::BeginPlay()
{
    Super::BeginPlay();
 
    // Remember the default data table. We will use this to reset it after reactivating the wrist menu if wanted.
    if(WidgetDataTable)
    {
        WidgetDataTableDefault = WidgetDataTable;
    }
 
    if(ParseWidgetDataTable())
    {
        CreateAllWidgets();
    }
}
 
void APixoVRWristMenu::IncreaseSelectedItem(int Amount)
{
    CurrentNormalAngleIndex = (CurrentNormalAngleIndex + Amount) % 8;
}
 
void APixoVRWristMenu::ResetToDefaultTable()
{
    // If Wrist Menu gets deactivated reset the Data Table if necessary.
    // This happens when a sub-menu was pressed.
    if(WidgetDataTableDefault != WidgetDataTable)
    {
        ClearAllWidgets();
        WidgetDataTable = WidgetDataTableDefault;
        if(ParseWidgetDataTable())
        {
            CreateAllWidgets();
        }
    }
}
 
void APixoVRWristMenu::ActivateWristMenu_Implementation(bool InActivate)
{
    // Did the BP programmer specify any menu data table?
    if(WidgetComponents.Num() == 0 && LargeWidgetComponents.Num() == 0)
    {
        // No ...
        UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Can't activate Wrist Menu. It seems the Widget Components aren't created. Did you specify a Wrist Menu Data Table?"));
        return;
    }
    
    bIsActivated = InActivate;
 
    SetActorTickEnabled(bIsActivated);
 
    if(Curve)
    {
        TimelineComponent->AddInterpFloat(Curve, TimelinePostUpdate);
        TimelineComponent->SetTimelineFinishedFunc(TimelineFinished);
        TimelineComponent->SetLooping(false);
        TimelineComponent->SetIgnoreTimeDilation(true);
 
        if(InActivate)
        {
            SetActorHiddenInGame(!InActivate);
 
            TimelineComponent->Play();
        }
        else
        {
            TimelineComponent->ReverseFromEnd();
        }
    }
    else
    {
        SetActorHiddenInGame(!bIsActivated);
        ResetToDefaultTable();
    }
}
 
void APixoVRWristMenu::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    if(bIsActivated)
    {
        TickWristMenu(DeltaTime);
    }
}
 
void APixoVRWristMenu::UpdateTrackpadPosition_Implementation(const FVector2D& Direction)
{
    if(!bIsActivated)
    {
        return;
    }
 
    CurrentPadDirection = Direction;
}
 
void APixoVRWristMenu::TickWristMenu(float DeltaTime)
{
    const APixoVRCharacter* Character = Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(this, 0));
    FRotator Rotator;
 
    const auto PlatformName = UGameplayStatics::GetPlatformName();
    
    if(Character && bAlignToPlayerHead)
    {
        Rotator = UKismetMathLibrary::FindLookAtRotation(Character->Head->GetComponentLocation(), RootComponent->GetComponentLocation());
        Rotator.Add(90.0f, 0.0f, 0.0f);
    }
    else
    {
        Rotator = UKismetMathLibrary::RInterpTo(RadialFloatingMesh->GetComponentRotation(), RootComponent->GetComponentRotation(), DeltaTime, RotationSpeed);
    }
 
    RadialFloatingMesh->SetWorldRotation(Rotator);
    
    // Calculate new orientation of the pointer arrow.
    CalculateRotationFromInput(CurrentPadDirection);
    
    RadialArrowMesh->SetRelativeRotation(CurrentArrowRotation);
 
    CurrentAngle = CurrentArrowRotation.Yaw;
    
    // We have to add and offset to the current angle to make the selection a bit easier.
    //CurrentAngle += AnglePerNormalItem * 0.5f;
    
    PreviousNormalAngleIndex = CurrentNormalAngleIndex;
    PreviousLargeAngleIndex = CurrentLargeAngleIndex;
 
    CurrentNormalAngleIndex = (static_cast<int>(CurrentAngle + (AnglePerNormalItem * 0.5f) + 270 + 22.5 * (WidgetComponents.Num() - 1)) % 360)/AnglePerNormalItem;
    CurrentLargeAngleIndex = (static_cast<int>(CurrentAngle + (AnglePerLargeItem * 0.5f) + 90 + 30 * (LargeWidgetComponents.Num() - 1)) % 360)/AnglePerLargeItem;
 
    //One set of instructions for the normal buttons
    if (PreviousNormalAngleIndex != CurrentNormalAngleIndex)
    {
        //Return any highlighted buttons to their normal states
        if ((PreviousNormalAngleIndex > -1) && PreviousNormalAngleIndex < WidgetComponents.Num())
        {
            Cast<UPixoVRWristMenuItemWidget>(WidgetComponents[PreviousNormalAngleIndex]->GetUserWidgetObject())->SetButtonHighlight(FLinearColor(.2525f, .2525f, .2525f, 1.0f));
            Cast<UPixoVRWristMenuItemWidget>(WidgetComponents[PreviousNormalAngleIndex]->GetUserWidgetObject())->SetRenderScale(FVector2D(1.0f, 1.0f));
        }
        
        // Highlight the new button and update the title text, if available
        if (CurrentNormalAngleIndex < WidgetComponents.Num())
        {
            CurrentPointedWidgetComponent = WidgetComponents[CurrentNormalAngleIndex];
            
            Cast<UPixoVRWristMenuItemWidget>(CurrentPointedWidgetComponent->GetUserWidgetObject())->SetButtonHighlight(DataTableRowsNormal[CurrentNormalAngleIndex]->HighlightColor);
            Cast<UPixoVRWristMenuItemWidget>(CurrentPointedWidgetComponent->GetUserWidgetObject())->SetRenderScale(FVector2D(1.25f, 1.25f));
            Cast<UPixoVRWristMenuItemTitleWidget>(Title->GetUserWidgetObject())->SetTitleText(DataTableRowsNormal[CurrentNormalAngleIndex]->TextTitle);
 
            AudioComponent->SetSound(HoverAudioCue);
            AudioComponent->Play();
        }
        else
        {
            CurrentPointedWidgetComponent = nullptr;
        }
    }
 
    // Another set of instructions for the large buttons.
    if (PreviousLargeAngleIndex != CurrentLargeAngleIndex)
    {
        // Return any highlighted buttons to their normal states
        if ((PreviousLargeAngleIndex > -1) && PreviousLargeAngleIndex < LargeWidgetComponents.Num())
        {
            Cast<UPixoVRWristMenuItemWidget>(LargeWidgetComponents[PreviousLargeAngleIndex]->GetUserWidgetObject())->SetButtonHighlight(FLinearColor(.2525f, .2525f, .2525f, 1.0f));
            //No scaling for large buttons
            //Cast<UPixoVRWristMenuItemWidget>(WidgetComponents[PreviousLargeAngleIndex]->GetUserWidgetObject())->SetRenderScale(FVector2D(1.0f, 1.0f));
        }
 
        // Highlight the new button and update the title text, if available
        if (CurrentLargeAngleIndex < LargeWidgetComponents.Num())
        {
            CurrentLargePointedWidgetComponent = LargeWidgetComponents[CurrentLargeAngleIndex];
            Cast<UPixoVRWristMenuItemWidget>(CurrentLargePointedWidgetComponent->GetUserWidgetObject())->SetButtonHighlight(DataTableRowsLarge[CurrentLargeAngleIndex]->HighlightColor);
            //Cast<UPixoVRWristMenuItemWidget>(CurrentLargePointedWidgetComponent->GetUserWidgetObject())->SetRenderScale(FVector2D(1.25f, 1.25f));
            Cast<UPixoVRWristMenuItemTitleWidget>(Title->GetUserWidgetObject())->SetTitleText(DataTableRowsLarge[CurrentLargeAngleIndex]->TextTitle);
            Cast<UPixoVRWristMenuItemTitleWidget>(Title->GetUserWidgetObject())->SetTitleColor(DataTableRowsLarge[CurrentLargeAngleIndex]->HighlightColor);
 
            AudioComponent->SetSound(HoverAudioCue);
            AudioComponent->Play();
        }
        else
        {
            CurrentLargePointedWidgetComponent = nullptr;
        }
    }
}
 
void APixoVRWristMenu::ClearAllWidgets()
{
    if (Title != nullptr)
    {
        Title->UnregisterComponent();
        const FDetachmentTransformRules DetachmentTransformRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, true);
        Title->DetachFromComponent(DetachmentTransformRules);
        Title->ConditionalBeginDestroy();
        Title = nullptr;
    }
    
    for(auto& WidgetComponent : WidgetComponents)
    {
        WidgetComponent->UnregisterComponent();
        FDetachmentTransformRules DetachmentTransformRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, true);
        WidgetComponent->DetachFromComponent(DetachmentTransformRules);
        WidgetComponent->ConditionalBeginDestroy();
        WidgetComponent = nullptr;
    }
 
    for (auto& WidgetComponent : LargeWidgetComponents)
    {
        WidgetComponent->UnregisterComponent();
        FDetachmentTransformRules DetachmentTransformRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, true);
        WidgetComponent->DetachFromComponent(DetachmentTransformRules);
        WidgetComponent->ConditionalBeginDestroy();
        WidgetComponent = nullptr;
    }
 
    WidgetComponents.Empty();
    LargeWidgetComponents.Empty();
    CurrentNormalAngleIndex = -1;
    CurrentLargeAngleIndex = -1;
    PreviousNormalAngleIndex = -1;
    PreviousLargeAngleIndex = -1;
}
 
EWristMenuItemCategory APixoVRWristMenu::SelectMenuItem()
{
    EWristMenuItemCategory MenuCategory = EWristMenuItemCategory::UNKNOWN;
 
    // Don't do anything if the wrist menu isn't activated.
    if(!bIsActivated || (CurrentNormalAngleIndex == -1))
    {
        return MenuCategory;
    }
 
    bool isNormalButton = false;
 
    if (CurrentNormalAngleIndex < WidgetComponents.Num())
    {
        MenuCategory = DataTableRowsNormal[CurrentNormalAngleIndex]->MenuCategory;
        isNormalButton = true;
    }
 
    else if (CurrentLargeAngleIndex < LargeWidgetComponents.Num())
    {
        MenuCategory = DataTableRowsLarge[CurrentLargeAngleIndex]->MenuCategory;
        isNormalButton = false;
    }
 
    // Handle all executable commands. The BP programmer will usually implement this.
    if(MenuCategory == EWristMenuItemCategory::EXECUTETABLE)
    {
        if(EventHandleObjects.Num() > 0)
        {
            for(const auto& EventHandleObject : EventHandleObjects)
            {
                if(EventHandleObject->Implements<UPixoVRWristMenuInterface>())
                {
                    if (isNormalButton == true) 
                    {
                        IPixoVRWristMenuInterface::Execute_OnWristMenuItemSelected(EventHandleObject, this, *DataTableRowsNormal[CurrentNormalAngleIndex]);
                    }
                    else if (isNormalButton == false)
                    {
                        IPixoVRWristMenuInterface::Execute_OnWristMenuItemSelected(EventHandleObject, this, *DataTableRowsLarge[CurrentLargeAngleIndex]);
                    }
                }
            }
        }
    }
    // Handle sub-menu commands.
    else if(MenuCategory == EWristMenuItemCategory::SUBMENU)
    {
        // TODO It might be better to cache this later so that we don't have to load the object over and over again.
        if (isNormalButton == true)
        {
            WidgetDataTable = LoadObject<UDataTable>(nullptr, *DataTableRowsNormal[CurrentNormalAngleIndex]->MenuItemID);
            UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Loading submenu data table: %s"), *DataTableRowsNormal[CurrentNormalAngleIndex]->MenuItemID);
        }
 
        else if (isNormalButton == false)
        {
            WidgetDataTable = LoadObject<UDataTable>(nullptr, *DataTableRowsLarge[CurrentLargeAngleIndex]->MenuItemID);
        }
 
        if(WidgetDataTable)
        {
            if(ParseWidgetDataTable())
            {
                CreateAllWidgets();
                CurrentNormalAngleIndex = INDEX_NONE;
                CurrentLargeAngleIndex = INDEX_NONE;
            }
            else
            {
                UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Parsing Widget Data Table failed."));
            }
        }
        else
        {
            if (isNormalButton == true) 
            {
                UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Couldn't load specified submenu data table: %s"), *DataTableRowsNormal[CurrentNormalAngleIndex]->MenuItemID);
            }
 
            if (isNormalButton == false) 
            {
                UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Couldn't load specified submenu data table: %s"), *DataTableRowsLarge[CurrentLargeAngleIndex]->MenuItemID);
            }
        }
    }
    
    AudioComponent->SetSound(SelectAudioCue);
    AudioComponent->Play();
    
    return MenuCategory;
}
 
bool APixoVRWristMenu::IsActivated()
{
    return bIsActivated;
}
 
void APixoVRWristMenu::CalculateRotationFromInput(const FVector2D& Direction)
{
    // Rotate input X+Y always point forward relative to the current pawn rotation.
    FVector A(Direction.X, Direction.Y, 0.0f);
    // Check whether thumb in near center (ignore rotation overrides).
    const bool Condition = A.Size() > ThumbDeadZone;
    if(Condition)
    {
        // We should normalize the vector.
        A.Normalize();
 
        // The second term adds an offset because the we like to put the zero angle to +90 degrees.
        CurrentArrowRotation = FRotationMatrix::MakeFromX(A).Rotator() + FRotator(0.0f, 180.0f, 0.0f);
    }
}
 
void APixoVRWristMenu::CalculateRotationByItemIndex(const int32 WristMenuItemIndex)
{
    if(WidgetComponents.IsValidIndex(WristMenuItemIndex))
    {
        if(const UPixoVRWristMenuItemWidget* Widget = Cast<UPixoVRWristMenuItemWidget>(WidgetComponents[WristMenuItemIndex]->GetWidget()))
        {
            CurrentArrowRotation.Yaw = Widget->GetButtonAngle() + 90.f;
        }
    }
}
 
void APixoVRWristMenu::AddIMenuItem(const FPixoVRWristMenuDataTableRow& InNewItemInfo)
{
    for (const auto& Row : DataTableRows)
    {
        if(Row->MenuItemID == InNewItemInfo.MenuItemID)
        {
            *Row = InNewItemInfo;
            ParseWidgetDataTableRows();
            CreateAllWidgets();
            return;
        }
    }
 
    FPixoVRWristMenuDataTableRow* NewItem = new FPixoVRWristMenuDataTableRow(InNewItemInfo);
    DataTableRows.Add(NewItem);
    ParseWidgetDataTableRows();
    CreateAllWidgets();
}
 
void APixoVRWristMenu::CreateAllWidgets()
{
    // Check if the BP programmer specified a menu data-table.
    if(DataTableRows.Num() == 0)
    {
        // No ...
        UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Can't create widgets because of some issues with the data table."));
        return;
    }
 
    ClearAllWidgets();
 
    //Add The Title Text Widget
    Title = NewObject<UWidgetComponent>(this);
    check(Title);
    const FAttachmentTransformRules TitleAttachmentTransformRules(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
    Title->AttachToComponent(RadialFloatingMesh, TitleAttachmentTransformRules, NAME_None);
    Title->RegisterComponent();
    Title->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    Title->SetGenerateOverlapEvents(false);
    Title->SetTwoSided(true);
    Title->SetOpacityFromTexture(1.0f); // Slate UIs have bogus opacity in their texture's alpha, so ignore texture alpha for VR
    Title->SetBackgroundColor(FLinearColor::Transparent);
    Title->SetBlendMode(EWidgetBlendMode::Masked);
    Title->SetRelativeScale3D(IconRelativeScale);
    Title->SetRelativeLocation(FVector(0.f, 0.f, 3.f));
 
    const FQuat TitleRotationPitch(FVector::RightVector, FMath::DegreesToRadians(90.0f));
    const FQuat TitleRotationYaw(FVector::UpVector, FMath::DegreesToRadians(180.0f));
    const FQuat TitleRotationRot = TitleRotationPitch * TitleRotationYaw;
 
    Title->SetRelativeRotation(TitleRotationRot);
 
 
    UPixoVRWristMenuItemTitleWidget *TitleWidget = CreateWidget<UPixoVRWristMenuItemTitleWidget>(GetWorld(), WristMenuTitleWidgetClass);
    check(TitleWidget);
    
    Title->SetWidget(TitleWidget);
 
    //Add the Radial Widgets
    uint32 WidgetItemPositionIndex = 0;
    uint32 LargeWidgetItemPositionIndex = 0;
    float NumberOfNormalButtonItems = 0;
    float NumberOfLargeButtonItems = 0;
    
    for (const auto& Row : DataTableRows)
    {
        if (Row->ButtonSize == EButtonSize::NORMAL) 
        {
            ++NumberOfNormalButtonItems;
        }
 
        if (Row->ButtonSize == EButtonSize::LARGE)
        {
            ++NumberOfLargeButtonItems;
        }
    }
    
    if ((static_cast<float>(NumberOfNormalButtonItems/MaxNumberOfNormalButtons)) + (static_cast<float>(NumberOfLargeButtonItems/MaxNumberOfLargeButtons)) > 1.0)
    {
        UE_LOG(LogPixoVRWristMenu, Warning, TEXT("There are too many menu items to fit on the wrist menu."));
        return;
    }
 
    for(const auto& Row : DataTableRows)
    {       
        UWidgetComponent* WidgetComponent = NewObject<UWidgetComponent>(this);
        check(WidgetComponent)
 
        FAttachmentTransformRules AttachmentTransformRules(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
        WidgetComponent->AttachToComponent(RadialFloatingMesh, AttachmentTransformRules, NAME_None);
        WidgetComponent->RegisterComponent();
        WidgetComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
        WidgetComponent->SetGenerateOverlapEvents(false);
        WidgetComponent->SetTwoSided(true);
        WidgetComponent->SetOpacityFromTexture( 1.0f ); // Slate UIs have bogus opacity in their texture's alpha, so ignore texture alpha for VR
        WidgetComponent->SetBackgroundColor( FLinearColor::Transparent );
        WidgetComponent->SetBlendMode( EWidgetBlendMode::Masked );
 
        float RadialX(0.0f);
        float RadialY(0.0f);
 
        if (Row->ButtonSize == EButtonSize::NORMAL)
        {
            RadialX = -IconRadialDistance * FMath::Sin((((WidgetItemPositionIndex - 2) % MaxNumberOfNormalButtons) - (0.5f * (NumberOfNormalButtonItems - 1))) * ((2.0f*PI) / MaxNumberOfNormalButtons));
            RadialY = IconRadialDistance * FMath::Cos((((WidgetItemPositionIndex - 2) % MaxNumberOfNormalButtons) - (0.5f * (NumberOfNormalButtonItems - 1))) * ((2.0f*PI) / MaxNumberOfNormalButtons));
        }
 
        if (Row->ButtonSize == EButtonSize::LARGE)
        {
            RadialX = -IconRadialDistance * FMath::Sin((((LargeWidgetItemPositionIndex + 1) % MaxNumberOfLargeButtons) - (0.5f * (NumberOfLargeButtonItems - 2))) * ((2.0f*PI) / MaxNumberOfLargeButtons));
            RadialY = IconRadialDistance * FMath::Cos((((LargeWidgetItemPositionIndex + 1) % MaxNumberOfLargeButtons) - (0.5f * (NumberOfLargeButtonItems - 2))) * ((2.0f*PI) / MaxNumberOfLargeButtons));
        }
 
        WidgetComponent->SetRelativeScale3D(IconRelativeScale);
        WidgetComponent->SetRelativeLocation(FVector(RadialX, RadialY, 2.5f));
 
        FQuat Rot = TitleRotationPitch * TitleRotationYaw;
 
        WidgetComponent->SetRelativeRotation(Rot);
 
        //Set the correct angle based on number of items
        
        // -------------------------------------------------------------------------
        // Add the Widget to the WidgetComponent.
        UPixoVRWristMenuItemWidget* Widget = CreateWidget<UPixoVRWristMenuItemWidget>(GetWorld(), WristMenuWidgetClass);
        check(Widget);
        
        WidgetComponent->SetWidget(Widget);
 
        Widget->SetButtonIcon(Row->IconTexture);
 
        if (Row->ButtonSize == EButtonSize::NORMAL)
        {
            Widget->SetButtonAngle((-22.5f * (NumberOfNormalButtonItems - 1)) + (45.0f * WidgetItemPositionIndex));
            WidgetItemPositionIndex++;
            WidgetComponents.Add(WidgetComponent);
        }
        else if (Row->ButtonSize == EButtonSize::LARGE)
        {
            Widget->SetButtonAngle(180.0f+(-30.00f * (NumberOfLargeButtonItems - 1)) + (60.0f * LargeWidgetItemPositionIndex));
            Widget->SetButtonScale(FVector2D(1.25f, 1.25f));
            LargeWidgetItemPositionIndex++;
            LargeWidgetComponents.Add(WidgetComponent);
        }
        // -------------------------------------------------------------------------
    }
 
    CalculateRotationByItemIndex(0);
}
 
bool APixoVRWristMenu::ParseWidgetDataTable()
{
    if(!WidgetDataTable)
    {
        UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Widget Data Table not specified. Can't parse Wrist Menu Table.") )
        return false;
    }
 
    DataTableRows.Empty();
    WidgetDataTable->GetAllRows<FPixoVRWristMenuDataTableRow>(TEXT(""), DataTableRows);
    
    if(!ParseWidgetDataTableRows())
    {
        return false;
    }
 
    AnglePerNormalItem = 360.0f / MaxNumberOfNormalButtons;
    AnglePerLargeItem = 360.0f / MaxNumberOfLargeButtons;
 
    return true;
}
 
bool APixoVRWristMenu::ParseWidgetDataTableRows()
{
    if(DataTableRows.Num() <= 0)
    {
        UE_LOG(LogPixoVRWristMenu, Warning, TEXT("Data Table Rows Array is empty. Can't parse Wrist Menu.") )
        return false;
    }
 
    DataTableRowsNormal.Empty();
    DataTableRowsLarge.Empty();
    
    for (const auto& Row : DataTableRows)
    {
        if (Row->ButtonSize == EButtonSize::NORMAL)
        {
            DataTableRowsNormal.Add(Row);
        }
        else if(Row->ButtonSize == EButtonSize::LARGE)
        {
            DataTableRowsLarge.Add(Row);
        }
    }
 
    return true;
}
 
void APixoVRWristMenu::SetEventHandlers(TArray<UObject*>& InEventHandleObjects)
{
    EventHandleObjects = InEventHandleObjects;
}
 
void APixoVRWristMenu::RebuildWristMenu(UDataTable* NewWidgetDataTable)
{
    if (NewWidgetDataTable == nullptr)
    {
        UE_LOG(LogTemp, Warning, TEXT("The new widget data table is empty, the rebuild process is stopped"));
        return;
    }
 
    ClearAllWidgets();
    
    WidgetDataTable = NewWidgetDataTable;
    WidgetDataTableDefault = NewWidgetDataTable;
 
    if (ParseWidgetDataTable())
    {
        CreateAllWidgets();
    }
}
 
void APixoVRWristMenu::HandleTimeLineFloat(float Value)
{
    RootComponent->SetWorldScale3D(FVector(Value, Value, Value));
}
 
void APixoVRWristMenu::HandleTimelineFinished()
{
    if(TimelineComponent->GetPlaybackPosition() <= 0.0f)
    {
        SetActorHiddenInGame(true);
        ResetToDefaultTable();
    }
}