WidgetController.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "UI/WidgetController.h"
 
#include "PixoVRCharacter.h"
#include "Components/BoxComponent.h"
#include "Components/TimelineComponent.h"
#include "Components/WidgetComponent.h"
#include "Interfaces/HandAnimationInterface.h"
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetMathLibrary.h"
#include "Serialization/ObjectAndNameAsStringProxyArchive.h"
#include "UI/BasicWidget.h"
#include "UI/ButtonListWidget.h"
#include "Net/UnrealNetwork.h"
 
AWidgetController::AWidgetController()
    : Super()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
    bReplicates = true;
 
    BoxForSpawn = CreateDefaultSubobject<UBoxComponent>(FName("BoxForSpawn"));
    if (BoxForSpawn)
    {
        RootComponent = BoxForSpawn;
        BoxForSpawn->SetBoxExtent(FVector(10.0f, 60.0f, 60.0f));
        BoxForSpawn->SetGenerateOverlapEvents(false);
    }
 
    BoxForRotate = CreateDefaultSubobject<UBoxComponent>(FName("BoxForRotate"));
    if (BoxForRotate)
    {
        BoxForRotate->SetupAttachment(RootComponent);
        BoxForRotate->SetBoxExtent(FVector(3.0f, 60.0f, 60.0f));
    }
 
    WidgetScene = CreateDefaultSubobject<USceneComponent>(FName("WidgetScene"));
    if (WidgetScene)
    {
        WidgetScene->SetupAttachment(RootComponent);
        WidgetScene->SetIsReplicated(true);
    }
 
    WidgetComponent = CreateDefaultSubobject<UWidgetComponent>(FName("Widget"));
    if (WidgetComponent)
    {
        WidgetComponent->SetupAttachment(WidgetScene);
        WidgetComponent->SetRelativeScale3D(FVector(0.1f, 0.1f, 0.1f));
        WidgetComponent->SetDrawSize(FVector2D(1200.0f, 1200.0f));
        WidgetComponent->SetTickWhenOffscreen(true);
        WidgetComponent->SetIsReplicated(true);
    }
 
    OpenCloseTimeline = CreateDefaultSubobject<UTimelineComponent>(TEXT("OpenCloseTimeline"));
 
    BoxForTouch = CreateDefaultSubobject<UBoxComponent>(FName("BoxForTouch"));
    if (BoxForTouch && WidgetComponent)
    {
        BoxForTouch->SetupAttachment(RootComponent);
        BoxForTouch->SetBoxExtent(FVector(60.0f, 60.0f, 60.0f));
        BoxForTouch->SetGenerateOverlapEvents(false);
    }
 
    static ConstructorHelpers::FObjectFinder<USoundWave> OpenSoundFinder(TEXT("SoundWave'/PixoCore/Audio/UI/UI_Open.UI_Open'"));
    OpenSound = OpenSoundFinder.Object;
    static ConstructorHelpers::FObjectFinder<USoundWave> CloseSoundFinder(TEXT("SoundWave'/PixoCore/Audio/UI/UI_Close.UI_Close'"));
    CloseSound = CloseSoundFinder.Object;
    static ConstructorHelpers::FObjectFinder<UCurveFloat> OpenCloseCurveFinder(TEXT("CurveFloat'/PixoCore/Blueprints/UI/OpenCloseWidgetCurve.OpenCloseWidgetCurve'"));
    OpenCloseFloatCurve = OpenCloseCurveFinder.Object;
}
 
// Called when the game starts or when spawned
void AWidgetController::BeginPlay()
{
    Super::BeginPlay();
    TimelinePostUpdate.BindDynamic(this, &AWidgetController::HandleTimeLineFloat);
    TimelineFinished.BindDynamic(this, &AWidgetController::HandleTimelineFinished);
 
    BoxForRotate->OnComponentBeginOverlap.AddDynamic(this, &AWidgetController::BeginOverlap);
    BoxForRotate->OnComponentEndOverlap.AddDynamic(this, &AWidgetController::EndOverlap);
 
    if (OpenCloseFloatCurve)
    {
        OpenCloseTimeline->AddInterpFloat(OpenCloseFloatCurve, TimelinePostUpdate);
        OpenCloseTimeline->SetTimelineFinishedFunc(TimelineFinished);
        OpenCloseTimeline->SetLooping(false);
        OpenCloseTimeline->SetIgnoreTimeDilation(true);
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("Timeline Curve Doesn't Set"));
    }
}
 
// Called every frame
void AWidgetController::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    const bool IsWidgetExist = WidgetComponent && WidgetComponent->GetUserWidgetObject();
    const APawn* FirstPlayerPawn = UGameplayStatics::GetPlayerPawn(GetWorld(), 0);
 
    if (FirstPlayerPawn && IsWidgetExist)
    {
        if (CanRotate())
        {
            const float TargetYaw = UKismetMathLibrary::FindLookAtRotation(FinalLocation, FirstPlayerPawn->GetActorLocation()).Yaw;
            FRotator ResultYaw = FMath::RInterpConstantTo(BoxForRotate->GetComponentRotation(), FRotator(0.0f, TargetYaw, 0.0f), DeltaTime, 200.0f);
            BoxForRotate->SetWorldRotation(ResultYaw);
            if (OverlapArray.Num() <= 0)
            {
                ResultYaw = FMath::RInterpConstantTo(WidgetComponent->GetComponentRotation(), FRotator(0.0f, TargetYaw, 0.0f), DeltaTime, 200.0f);
                WidgetComponent->SetWorldRotation(ResultYaw);
            }
        }
 
        const FVector InstigatorLocation = FirstPlayerPawn->GetActorLocation();
        if (!InstigatorLocation.Equals(FVector::ZeroVector, 1.0f))
        {
            const float SquaredDistance2D = FVector::DistSquared2D(InstigatorLocation, FinalLocation);
            UBasicWidget* BasicWidget = Cast<UBasicWidget>(WidgetComponent->GetUserWidgetObject());
            BasicWidget->ProcessSquaredDistanceToPlayer(SquaredDistance2D, DeltaTime);
        }
    }
}
 
void AWidgetController::InitWidget(UBasicWidgetInfo* WidgetInfo)
{
    if (WidgetInfo)
    {
        InitWidgetLocally(WidgetInfo);
    }
}
 
void AWidgetController::InitWidgetLocally(UBasicWidgetInfo* WidgetInfo)
{
    if (WidgetInfo->bModal && CurrentWidget)
    {
        WidgetQueue.AddTail(CurrentWidget); // need check
        DeactivateCurrentWidget();
    }
 
    const bool NeedToCreateNewWidget = CurrentWidget == nullptr || CurrentWidget->GetGuid() != WidgetInfo->Guid;
 
    if (NeedToCreateNewWidget)
    {
        if (WidgetInfo->bIsUpdateRequest)
        {
            UE_LOG(LogTemp, Warning, TEXT("WidgetController can't open widget by UpdateRequest"));
            return;
        }
 
        UUserWidget* NewWidget = CreateWidget(GetWorld(), WidgetInfo->WidgetClass);
        WidgetComponent->SetWidget(NewWidget);
        OpenWidgetAnim();
    }
 
    if (WidgetInfo->bUseTouchToInteractWithWidget)
    {
        BoxForTouch->SetGenerateOverlapEvents(true);
        BoxForTouch->OnComponentBeginOverlap.AddDynamic(this, &AWidgetController::TouchBeginOverlap);
        BoxForTouch->OnComponentEndOverlap.AddDynamic(this, &AWidgetController::TouchEndOverlap);
    }
 
    if (UBasicWidget* BasicWidget = Cast<UBasicWidget>(WidgetComponent->GetUserWidgetObject()))
    {
        InitBasicWidget(BasicWidget, WidgetInfo);
        BasicWidget->OnPlayerWentAway.BindUObject(this, &AWidgetController::CloseWidget);
    }
 
    if (bFinalLocationPendingChange)
    {
        OpenWidgetAnim();
    }
}
 
void AWidgetController::InitBasicWidget(UBasicWidget* BasicWidget, UBasicWidgetInfo* WidgetInfo)
{
    BasicWidget->Init(WidgetInfo);
    SetActorEnableCollision(true);
 
    // if (CurrentWidget && CurrentWidget->IsForcedToExecuteCloseCallback())
    // {
    //  CurrentWidget->OnExitMenuEventDelegate.ExecuteIfBound(nullptr);
    // }
    CurrentWidget = BasicWidget;
    CurrentWidget->SetCustomGuid(WidgetInfo->Guid);
 
    if (WidgetInfo->UseCustomWidgetPosition)
    {
        FinalLocation = WidgetInfo->Location;
        FinalRotation = WidgetInfo->Rotator;
    }
    else
    {
        FinalLocation = GetActorLocation();
        FinalRotation = GetActorRotation();
    }
 
    bRotateAllowed = WidgetInfo->bCanRotate;
    bSoundAllowed = WidgetInfo->bPlayOpenCloseSound;
 
    UWorld* ThisWorld = GetWorld();
    if (OpenSound && ThisWorld && ThisWorld->bAllowAudioPlayback && !ThisWorld->IsNetMode(NM_DedicatedServer) && bSoundAllowed)
    {
        UGameplayStatics::PlaySound2D(ThisWorld, OpenSound);
    }
}
 
void AWidgetController::TouchBeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (const APixoVRHand* HandOverlapping = Cast<APixoVRHand>(OtherActor))
    {
        IHandAnimationInterface::Execute_SetAnimationGripState(HandOverlapping->HandMesh->GetAnimInstance(), EPixoVRGripState::PointFinger);
        HandOverlapping->TouchComponent->Activate();
    }
}
 
void AWidgetController::TouchEndOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    if (const APixoVRHand* HandOverlapping = Cast<APixoVRHand>(OtherActor))
    {
        IHandAnimationInterface::Execute_SetAnimationGripState(HandOverlapping->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        HandOverlapping->TouchComponent->Deactivate();
    }
}
 
void AWidgetController::CloseWidget()
{
    InternalCloseWidget();
}
 
bool AWidgetController::IsWidgetInited()
{
    if (CurrentWidget->IsValidLowLevel())
        return true;
 
    return false;
}
 
void AWidgetController::InternalCloseWidget()
{
    if (auto Tail = WidgetQueue.GetTail())
    {
        CurrentWidget = Tail->GetValue();
        WidgetQueue.RemoveNode(Tail);
        WidgetComponent->SetWidget(nullptr);
        ActivateCurrentWidget();
    }
    else if (WidgetComponent->GetUserWidgetObject())
    {
        ensure(CurrentWidget);
        CurrentWidget->OnClickExitMenuEvent(FText::GetEmpty());
        CurrentWidget->MarkPendingKill();
        CurrentWidget = nullptr;
 
        BoxForTouch->OnComponentBeginOverlap.Clear();
        BoxForTouch->OnComponentEndOverlap.Clear();
 
        SetActorEnableCollision(false);
        CloseWidgetAnim();
 
        UWorld* ThisWorld = GetWorld();
        if (CloseSound && ThisWorld && ThisWorld->bAllowAudioPlayback && !ThisWorld->IsNetMode(NM_DedicatedServer) && bSoundAllowed)
        {
            UGameplayStatics::PlaySound2D(ThisWorld, CloseSound);
        }
    }
}
 
void AWidgetController::OpenWidgetAnim()
{
    OpenCloseTimeline->PlayFromStart();
}
 
void AWidgetController::CloseWidgetAnim()
{
    StopLookAt();
    OpenCloseTimeline->ReverseFromEnd();
}
 
void AWidgetController::StartLookAt()
{
    bStartLookAtAllowed = true;
}
 
void AWidgetController::StopLookAt()
{
    bStartLookAtAllowed = false;
}
 
bool AWidgetController::CanRotate()
{
    return bStartLookAtAllowed && bRotateAllowed;
}
 
void AWidgetController::ActivateCurrentWidget()
{
    if (CurrentWidget)
    {
        WidgetComponent->SetWidget(CurrentWidget);
        CurrentWidget->SetVisibility(ESlateVisibility::Visible);
    }
}
 
void AWidgetController::DeactivateCurrentWidget()
{
    if (CurrentWidget)
    {
        CurrentWidget->SetVisibility(ESlateVisibility::Collapsed);
        WidgetComponent->SetWidget(nullptr);
    }
}
 
void AWidgetController::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
    DOREPLIFETIME(AWidgetController, FinalLocation);
    //DOREPLIFETIME(AWidgetController, StartLocation);
    DOREPLIFETIME(AWidgetController, FinalRotation);
    //DOREPLIFETIME(AWidgetController, StartRotation);
    DOREPLIFETIME(AWidgetController, WidgetComponent);
    DOREPLIFETIME(AWidgetController, OpenCloseTimeline);
}
 
void AWidgetController::HandleTimeLineFloat(float Value)
{
    WidgetScene->SetWorldScale3D(FVector(Value, Value, Value));
    if (OpenCloseTimeline->IsPlaying())
    {
        SetActorLocation(FinalLocation);
        FRotator NewRotation = FinalRotation;
        SetActorRotation(NewRotation);
        BoxForRotate->SetWorldRotation(NewRotation);
        WidgetComponent->SetWorldRotation(NewRotation);
    }
}
 
void AWidgetController::HandleTimelineFinished()
{
    if (OpenCloseTimeline->GetPlaybackPosition() > 0)
    {
        SetActorLocation(FinalLocation);
        StartLookAt();
    }
    else
    {
        WidgetComponent->SetWidget(nullptr);
    }
}
 
void AWidgetController::BeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult &SweepResult)
{
    if (OtherComp != BoxForTouch)
    {
        OverlapArray.AddUnique(OtherComp);
    }
}
 
void AWidgetController::EndOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
    if (OtherComp != BoxForTouch)
    {
        OverlapArray.Remove(OtherComp);
    }
}