BaseWristMenu.cpp

Go to the documentation of this file.

// Copyright(c) 2018 PixoVR, LLC. All Rights Reserved.
 
 
#include "CharacterTools/WristMenu/BaseWristMenu.h"
#include "CharacterTools/WristMenu/BaseWristMenuButton.h"
#include "Interfaces/HandAnimationInterface.h"
#include "Interfaces/WristMenuWidgetInterface.h"
#include "Kismet/GameplayStatics.h"
 
bool ABaseWristMenu::bCanOpenWristMenu = true;
 
ABaseWristMenu::ABaseWristMenu()
{
    PrimaryActorTick.bCanEverTick = true;
 
    WristMenuButton = CreateDefaultSubobject<UChildActorComponent>(TEXT("WristMenuButton"));
    SetRootComponent(WristMenuButton);
    
    WristMenuWidget = CreateDefaultSubobject<UWidgetComponent>(TEXT("WristMenuWidget"));
    WristMenuWidget->SetupAttachment(RootComponent);
 
    PointingFingerCollisionComp = CreateDefaultSubobject<UBoxComponent>("PointingFingerCollision");
    PointingFingerCollisionComp->SetupAttachment(WristMenuWidget);
 
    /*
    PointingFingerCollisionComp->OnComponentBeginOverlap.AddDynamic(this,
        &ABaseWristMenu::OnBeginOverlapPointingFingerCollision);
    PointingFingerCollisionComp->OnComponentEndOverlap.AddDynamic(this,
        &ABaseWristMenu::OnEndOverlapPointingFingerCollision);
    */
}
 
void ABaseWristMenu::BeginPlay()
{
    Super::BeginPlay();
 
    HideWristMenu();
 
    if (ABaseWristMenuButton* WristMenuButtonActor = Cast<ABaseWristMenuButton>(WristMenuButton->GetChildActor()))
    {
        WristMenuButtonActor->OnWristMenuButtonPressed.AddDynamic(this, &ABaseWristMenu::OnWristMenuButtonPressed);
    }
    
    if (APixoVRHand* HandOwner = Cast<APixoVRHand>(GetParentActor()))
    {
        if(HandOwner->HandMotionSource == EControllerHand::Left)
        {
            // Adjusting relative location and rotation for the left hand
            WristMenuWidget->SetRelativeLocation(WristMenuWidget->GetRelativeLocation() * FVector(1.0f, -1.0f, 1.0f));          
            USceneComponent* RootParent = RootComponent->GetAttachParent();
            if (RootParent)
            {
                FVector RelativeLocation = RootParent->GetRelativeLocation();
                RootParent->SetRelativeLocation(RelativeLocation * FVector(1.0f, -1.0f, 1.0f));
                RootParent->AddRelativeRotation(FRotator(0.0f, 0.0f, 180.0f));
            }
        }
    }
 
    if (GetWorld())
        CameraManagerRef = UGameplayStatics::GetPlayerCameraManager(GetWorld(), 0);
}
 
void ABaseWristMenu::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    FVector WristMenuActivationDirection;
    if (CameraManagerRef)
        WristMenuActivationDirection = GetActorLocation() - CameraManagerRef->GetCameraLocation();
    WristMenuActivationDirection.Normalize();
    
    const float WristMenuToActivationAngleDifference = FMath::RadiansToDegrees(FMath::Acos(FVector::DotProduct(GetActorUpVector() * -1.0f, WristMenuActivationDirection)));
    
    bool bIsWristDirectionBetweenTolerance = WristMenuToActivationAngleDifference < WristAngleTolerance;
    
    if (bCanOpenWristMenu && bIsWristDirectionBetweenTolerance && !IsWristMenuOpened())
    {
        if (!WristMenuWidget->GetWidget()->GetClass()->ImplementsInterface(UWristMenuWidgetInterface::StaticClass())
            || IWristMenuWidgetInterface::Execute_IsWidgetShouldBeDisplayed(WristMenuWidget->GetWidget()))
        {
            bCanOpenWristMenu = false;
            SetButtonVisibility(true);
        }
    }
    else if (!bCanOpenWristMenu && !bIsWristDirectionBetweenTolerance && IsWristMenuOpened())
    {
        HideWristMenu();
    }
 
}
 
void ABaseWristMenu::SetButtonVisibility(bool IsVisible)
{
    if (!WristMenuButton)
        return;
    
    WristMenuButton->SetHiddenInGame(!IsVisible);
    WristMenuButton->GetChildActor()->SetActorEnableCollision(IsVisible);
    const ABaseWristMenuButton* BaseWristMenuButton = Cast<ABaseWristMenuButton>(WristMenuButton->GetChildActor());
    if (BaseWristMenuButton)
    {
        BaseWristMenuButton->PointingFingerCollisionComp->SetCollisionEnabled(IsVisible ?
            ECollisionEnabled::QueryOnly : ECollisionEnabled::NoCollision); 
    }
}
 
void ABaseWristMenu::SetUIVisibility(bool IsVisible)
{
    if (!WristMenuWidget)
        return;
    
    WristMenuWidget->SetHiddenInGame(!IsVisible);
    WristMenuWidget->SetCollisionEnabled(IsVisible ? ECollisionEnabled::QueryOnly : ECollisionEnabled::NoCollision);
    PointingFingerCollisionComp->SetCollisionEnabled(IsVisible ?
        ECollisionEnabled::QueryOnly : ECollisionEnabled::NoCollision); 
}
 
void ABaseWristMenu::OnWristMenuButtonPressed()
{
    if (!WristMenuButton)
        return;
    
    if (WristMenuButton->IsVisible())
    {
        SetButtonVisibility(false);
        SetUIVisibility(true);
        OnWristMenuButtonPressedDelegate.Broadcast();
    }
}
 
void ABaseWristMenu::HideWristMenu()
{
    bCanOpenWristMenu = true;
    SetButtonVisibility(false);
    SetUIVisibility(false);
    if (WristMenuWidget->GetWidget()->GetClass()->ImplementsInterface(UWristMenuWidgetInterface::StaticClass()))
    {
        IWristMenuWidgetInterface::Execute_ResetWidget(WristMenuWidget->GetWidget());
    }
}
 
bool ABaseWristMenu::IsWristMenuOpened()
{
    return !WristMenuButton->bHiddenInGame || !WristMenuWidget->bHiddenInGame;
}
 
void ABaseWristMenu::OnBeginOverlapPointingFingerCollision(UPrimitiveComponent* OverlappedComponent,
                                        AActor* OtherActor, UPrimitiveComponent* OtherComp,
                                        int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    OnPointingFingerCollisionOverlapChange(OtherActor, true);
}
 
void ABaseWristMenu::OnEndOverlapPointingFingerCollision(UPrimitiveComponent* OverlappedComponent,
                                        AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    OnPointingFingerCollisionOverlapChange(OtherActor, false);
}
 
void ABaseWristMenu::OnPointingFingerCollisionOverlapChange(AActor* OtherActor, bool IsBeginOverlap) const
{
    const APixoVRHand* Hand = Cast<APixoVRHand>(OtherActor);
    if (Hand)
    {
        /* If overlapping hand doesn't hold object */
        if (!Hand->HandHoldingObject && (!Hand->LaserMesh || !Hand->LaserMesh->IsVisible()))
        {
            /* Change hand animation and allow widget interaction using touch */
            if (IsBeginOverlap)
            {
                IHandAnimationInterface::Execute_SetAnimationGripState(
                    Hand->HandMesh->GetAnimInstance(), EPixoVRGripState::PointFinger);
                Hand->TouchComponent->Activate();
            }
            else
            {
                IHandAnimationInterface::Execute_SetAnimationGripState(
                    Hand->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
                Hand->TouchComponent->Deactivate();
            }
        }
    }
}