InteractionButton.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "InteractableObjects/InteractionButton.h"
#include "PixoVRCharacter.h"
#include "Components/SphereComponent.h"
#include "Kismet/GameplayStatics.h"
#include "NavAreas/NavArea_Obstacle.h"
 
AInteractionButton::AInteractionButton()
{
    PrimaryActorTick.bCanEverTick = true;
    bReplicates = true;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> ButtonMeshFinder(
        TEXT("StaticMesh'/PixoCore/Meshes/InteractableObjects/SM_ButtonMoving.SM_ButtonMoving'"));
    UStaticMesh* ButtonMesh = ButtonMeshFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> ButtonSupportMeshFinder(
        TEXT("StaticMesh'/PixoCore/Meshes/InteractableObjects/SM_ButtonSupport.SM_ButtonSupport'"));
    UStaticMesh* ButtonSupportMesh = ButtonSupportMeshFinder.Object;
 
    USceneComponent* DefaultRootComponent = CreateDefaultSubobject<USceneComponent>("DefaultRootComponent");
    SetRootComponent(DefaultRootComponent);
 
    ButtonSupportComp = CreateDefaultSubobject<UStaticMeshComponent>("ButtonSupport");
    ButtonSupportComp->SetupAttachment(GetRootComponent());
    ButtonSupportComp->SetStaticMesh(ButtonSupportMesh);
    ButtonSupportComp->SetRelativeRotation(FRotator(0.0f, 0.0f, 90.0f));
 
    ButtonMovingComp = CreateDefaultSubobject<UStaticMeshComponent>("ButtonMoving");
    ButtonMovingComp->SetupAttachment(ButtonSupportComp);
    ButtonMovingComp->SetStaticMesh(ButtonMesh);
    ButtonMovingComp->SetRelativeLocation(FVector(0.0f, -1.4f, 0.0f));
 
    BoxCollisionComp = CreateDefaultSubobject<UBoxComponent>("BoxCollision");
    BoxCollisionComp->SetupAttachment(ButtonMovingComp);
    BoxCollisionComp->AreaClass = UNavArea_Obstacle::StaticClass();
    BoxCollisionComp->SetBoxExtent(FVector(4.0f, 1.0f, 4.0f));
    BoxCollisionComp->OnComponentBeginOverlap.AddDynamic(this, &AInteractionButton::OnBeginOverlapButton);
 
    PointLightComp = CreateDefaultSubobject<UPointLightComponent>("PointLight");
    PointLightComp->SetupAttachment(ButtonMovingComp);
    PointLightComp->SetIntensity(100.f);
    PointLightComp->SetAttenuationRadius(20.f);
    PointLightComp->SetSoftSourceRadius(10.f);
    PointLightComp->SetCastShadows(false);
    PointLightComp->SetLightColor(FLinearColor::Green);
 
    TextRenderComp = CreateDefaultSubobject<UTextRenderComponent>("TextRender");
    TextRenderComp->SetupAttachment(ButtonSupportComp);
    TextRenderComp->SetText(FText::FromName(ButtonText));
    TextRenderComp->SetWorldSize(20.f);
    TextRenderComp->SetHorizontalAlignment(EHTA_Center);
    TextRenderComp->SetVerticalAlignment(EVRTA_TextCenter);
    TextRenderComp->SetRelativeRotation(FRotator(0.0f, 0.0f, -90.0f));
    TextRenderComp->SetRelativeLocation(FVector(0.0f, -15.0f, 0.0f));
}
 
void AInteractionButton::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
 
    MovingButtonTimeLine.TickTimeline(DeltaSeconds);
}
 
void AInteractionButton::SetButtonVisibility(bool bVisible)
{
    ButtonSupportComp->SetVisibility(bVisible);
    ButtonMovingComp->SetVisibility(bVisible);
    BoxCollisionComp->SetVisibility(bVisible);
    BoxCollisionComp->SetCollisionEnabled(
        bVisible ? ECollisionEnabled::QueryAndPhysics : ECollisionEnabled::NoCollision);
    PointLightComp->SetVisibility(bVisible);
    TextRenderComp->SetVisibility(bVisible);
}
 
void AInteractionButton::SetButtonState(EButtonState InButtonState)
{
    CurrentButtonState = InButtonState;
    switch (CurrentButtonState)
    {
    case EButtonState::BS_Default:
        PointLightComp->SetLightColor(FLinearColor::Green);
        ButtonMovingComp->SetVectorParameterValueOnMaterials("ButtonColor", FVector(0.207881f, 0.71875f, 0.074695f));
        break;
 
    case EButtonState::BS_Pressed:
        PointLightComp->SetLightColor(FLinearColor::Red);
        ButtonMovingComp->SetVectorParameterValueOnMaterials("ButtonColor", FVector(1.f, 0.f, 0.f));
        break;
 
    case EButtonState::BS_Disabled:
        PointLightComp->SetLightColor(FLinearColor(0.1f, 0.1f, 0.1f));
        ButtonMovingComp->SetVectorParameterValueOnMaterials("ButtonColor", FVector(0.1f, 0.1f, 0.1f));
        break;
 
    default:
        break;
    }
}
 
void AInteractionButton::SetButtonName(const FName& InButtonName)
{
    if (TextRenderComp)
    {
        TextRenderComp->SetText(FText::FromName(InButtonName));
    }
}
 
void AInteractionButton::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(AInteractionButton, ButtonText);
}
 
void AInteractionButton::BeginPlay()
{
    Super::BeginPlay();
 
    if (MovingButtonCurve != nullptr)
    {
        FOnTimelineFloat TimelineProgress;
        TimelineProgress.BindUFunction(this, FName("MovingButtonTimelineProgress"));
        MovingButtonTimeLine.AddInterpFloat(MovingButtonCurve, TimelineProgress);
 
        FOnTimelineEventStatic TimelineFinished;
        TimelineFinished.BindUFunction(this, FName("MovingButtonTimelineFinished"));
        MovingButtonTimeLine.SetTimelineFinishedFunc(TimelineFinished);
 
        MovingButtonTimeLine.SetLooping(false);
        MovingButtonTimeLine.SetDirectionPropertyName("TimelineDirection");
    }
    
        TextRenderComp->SetHiddenInGame(!bIsButtonHaveText);
}
 
void AInteractionButton::ButtonPress_Implementation()
{
    bIsPressed = true;
    SetButtonState(EButtonState::BS_Pressed);
    TimelineDirection = ETimelineDirection::Forward;
    MovingButtonTimeLine.PlayFromStart();
    UGameplayStatics::PlaySoundAtLocation(this, ButtonPressSound, ButtonMovingComp->GetComponentLocation(),
                                          ButtonPressSound->GetVolumeMultiplier(),
                                          ButtonPressSound->GetPitchMultiplier(), 0.f,
                                          ButtonPressSound->AttenuationSettings);
}
 
void AInteractionButton::ButtonRelease_Implementation()
{
    ButtonPressedDelegate.Broadcast(PlayerController);
    TimelineDirection = ETimelineDirection::Backward;
    MovingButtonTimeLine.ReverseFromEnd();
}
 
void AInteractionButton::OnBeginOverlapButton(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
                                              UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep,
                                              const FHitResult& SweepResult)
{
    if (bIsPressed || GetButtonState() == EButtonState::BS_Disabled)
    {
        return;
    }
 
    if (APixoVRHand* Hand = Cast<APixoVRHand>(OtherActor))
    {
        if (Hand->HandMotionSource == EControllerHand::Left)
        {
            PlayerController = Cast<APlayerController>(Hand->OwningCharacter->GetController());
            const FForceFeedbackParameters ForceFeedbackParameters;
            PlayerController->ClientPlayForceFeedback(LeftHandFeedbackEffect, ForceFeedbackParameters);
        }
        else if (Hand->HandMotionSource == EControllerHand::Right)
        {
            PlayerController = Cast<APlayerController>(Hand->OwningCharacter->GetController());
            const FForceFeedbackParameters ForceFeedbackParameters;
            PlayerController->ClientPlayForceFeedback(RightHandFeedbackEffect, ForceFeedbackParameters);
        }
        else
        {
            return;
        }
 
        ButtonPress();
    }
}
 
void AInteractionButton::MovingButtonTimelineProgress(float Value)
{
    ButtonMovingComp->SetRelativeLocation(FVector(ButtonMovingComp->GetRelativeLocation().X, Value,
                                                  ButtonMovingComp->GetRelativeLocation().Z));
}
 
void AInteractionButton::MovingButtonTimelineFinished()
{
    switch (TimelineDirection)
    {
    case ETimelineDirection::Forward:
        ButtonRelease();
        break;
 
    case ETimelineDirection::Backward:
        if (CurrentButtonState != EButtonState::BS_Disabled)
        {
            SetButtonState(EButtonState::BS_Default);
        }
        ButtonReleasedDelegate.Broadcast(PlayerController);
        bIsPressed = false;
        break;
 
    default:
        break;
    }
}