PixoVRCharacter.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "PixoVRCharacter.h"
#include "PixoVRInputAdapter.h"
#include "CharacterTools/PixoVRCircleProgress.h"
#include "CharacterTools/Teleporters/PixoVRTeleporter.h"
#include "CharacterTools/PixoVRLaser.h"
#include "CharacterTools/PixoVRLongHoldComponent.h"
#include "CharacterTools/PixoVRWristMenu.h"
#include "CharacterTools/Teleporters/BySpotTeleporter.h"
#include "CharacterTools/WorkTools/PixoVRToolBase.h"
#include "Components/BillboardComponent.h"
#include "GameFramework/GameModeBase.h"
#include "Grippables/GrippableActor.h"
#include "Interfaces/GripResponseAnimationInterface.h"
#include "Interfaces/HandAnimationInterface.h"
#include "Interfaces/PixoCoreInterface.h"
#include "Interfaces/PixoVRInteractiveObject.h"
#include "Kismet/GameplayStatics.h"
#include "Managers/HintManager.h"
 
DEFINE_LOG_CATEGORY(LogPixoVRCharacter);
 
APixoVRCharacter::APixoVRCharacter()
    : DefaultPlayerHeight(165)
      , bLaserBeamActive(false)
      , LeftTeleporterSocket(NAME_None)
      , RightTeleporterSocket(NAME_None)
      , TeleportControllerLeft(nullptr)
      , TeleportControllerRight(nullptr)
      , LeftLaserBeamSocket(NAME_None)
      , RightLaserBeamSocket(NAME_None)
      , LaserControllerLeft(nullptr)
      , LaserControllerRight(nullptr)
      , bLeftLaserBeamIsActiveOnStart(false)
      , bRightLaserBeamIsActiveOnStart(false)
      , WristMenuLoc(nullptr)
      , ProgressBarClass(APixoVRCircleProgress::StaticClass())
      , WristMenuSocket(FName("WristMenuSocket"))
      , WristMenu(nullptr)
      , MirroredWristMenuScale(FVector(1, -1, -1))
      , ToolSocket("ToolSocket")
      , BaseTurnRate(45.0f)
      , BaseLookUpRate(45.0f)
      , bDisableToolsInputBindings(false)
      , Head(nullptr)
      , Body(nullptr)
{
    PrimaryActorTick.bCanEverTick = true;
 
    bReplicates = true;
    SetReplicateMovement(true);
    bNetLoadOnClient = true;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> HeadMeshFinder(
        TEXT("StaticMesh'/PixoCore/Meshes/SM_PlayerHead.SM_PlayerHead'"));
    UStaticMesh* HeadMesh = HeadMeshFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UMaterialInstance> HeadMeshMaterialFinder(
        TEXT("MaterialInstanceConstant'/PixoCore/Materials/MI_PlayerHead.MI_PlayerHead'"));
    UMaterialInstance* HeadMeshMaterial = HeadMeshMaterialFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> BodyMeshFinder(
        TEXT("StaticMesh'/PixoCore/Meshes/BasicShapes/Cylinder.Cylinder'"));
    UStaticMesh* BodyMesh = BodyMeshFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UMaterial> BodyMeshMaterialFinder(
        TEXT("Material'/PixoCore/Materials/Body/BasicShapeMaterialTrans.BasicShapeMaterialTrans'"));
    UMaterial* BodyMeshMaterial = BodyMeshMaterialFinder.Object;
 
    TeleportControllerClass = APixoVRTeleporter::StaticClass();
    LaserControllerClass = APixoVRLaser::StaticClass();
    WristMenuClass = APixoVRWristMenu::StaticClass();
 
    Head = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("HeadMesh"));
    Head->SetStaticMesh(HeadMesh);
    Head->SetMaterial(0, HeadMeshMaterial);
    Head->SetRelativeLocation(FVector(0.0f, 0.0f, -15.0f));
    Head->SetRelativeRotation(FRotator(0.0f, -90.0f, 0.0f));
    Head->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    Head->SetupAttachment(VRReplicatedCamera);
 
    Body = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BodyMesh"));
    Body->SetStaticMesh(BodyMesh);
    Body->SetMaterial(0, BodyMeshMaterial);
    Body->SetRelativeLocation(FVector(-8.0f, 0.0f, -160.0f));
    Body->SetRelativeScale3D(FVector(0.5f, 0.5f, 0.1f));
    Body->SetCollisionProfileName(UCollisionProfile::CustomCollisionProfileName);
    Body->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    Body->SetCollisionObjectType(ECollisionChannel::ECC_Pawn);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_WorldStatic, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_WorldDynamic, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_Pawn, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_PhysicsBody, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_Vehicle, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_Destructible, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_Visibility, ECollisionResponse::ECR_Overlap);
    Body->SetCollisionResponseToChannel(ECollisionChannel::ECC_Camera, ECollisionResponse::ECR_Overlap);
    Body->SetupAttachment(ParentRelativeAttachment);
 
    bUseControllerRotationPitch = true;
    bUseControllerRotationYaw = true;
    bUseControllerRotationRoll = false;
 
    VRReplicatedCamera->bUsePawnControlRotation = false;
    VRReplicatedCamera->bLockToHmd = true;
    VRReplicatedCamera->bAutoSetLockToHmd = true;
    VRReplicatedCamera->SetRelativeLocation(FVector(0.0f, 0.0f, DefaultPlayerHeight));
 
    WristMenuLoc = CreateDefaultSubobject<UBillboardComponent>(TEXT("Wrist Menu PC Location"));
    WristMenuLoc->SetRelativeScale3D(FVector(.25f, .25f, .25f));
    WristMenuLoc->SetRelativeLocation(FVector(50.0f, 2.0f, .0f));
    WristMenuLoc->SetupAttachment(VRReplicatedCamera);
 
    InputAdapter = NewObject<UPixoVRInputAdapter>();
    LongHoldComponent = CreateDefaultSubobject<UPixoVRLongHoldComponent>(TEXT("LongHoldComponent"));
 
    FadeSphere = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("FadeSphere"));
    FadeSphere->SetupAttachment(VRReplicatedCamera);
    static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMeshAsset(
        TEXT("StaticMesh'/Engine/BasicShapes/Sphere.Sphere'"));
    FadeSphere->SetStaticMesh(SphereMeshAsset.Object);
    static ConstructorHelpers::FObjectFinder<UMaterial> FadeSphereMaterialAsset(
        TEXT("Material'/PixoCore/Materials/Controller/M_FadeMaterial.M_FadeMaterial'"));
    FadeSphere->SetMaterial(0, FadeSphereMaterialAsset.Object);
    FadeSphere->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    FadeSphere->SetCollisionEnabled(ECollisionEnabled::NoCollision);
 
    //Causes crashes on PICO 
    //UBlueprintGeneratedClass* DefaultVRHandClass = Cast<UBlueprintGeneratedClass>(StaticLoadClass(UObject::StaticClass(), nullptr,TEXT("/PixoCore/Blueprints/Hands/BP_PixoVRHand.BP_PixoVRHand_C")));
    //VRHandClass = DefaultVRHandClass;
}
 
 
void APixoVRCharacter::BeginPlay()
{
    Super::BeginPlay();
 
    OnDestroyed.AddDynamic(this, &APixoVRCharacter::PlayerDestroyed);
 
    if (GetLocalRole() == ROLE_Authority && GetWorld()->GetAuthGameMode()->GetClass()->ImplementsInterface(UPixoCoreInterface::StaticClass()))
    {
        HintManager = Cast<UHintManager>(IPixoCoreInterface::Execute_GetManagerRef(GetWorld()->GetAuthGameMode(), UHintManager::StaticClass()));
    }
    
    // We will spawn here only on the clients. The server will spawn the tools when this character gets possessed by a new controller.
    if(!HasAuthority())
    {
        SpawnTeleporter(EControllerHand::Left, true);
        SpawnTeleporter(EControllerHand::Right, true);
    }
    
    const auto DeviceName = UHeadMountedDisplayFunctionLibrary::GetHMDDeviceName();
    
    UE_LOG(LogPixoVRCharacter, Log, TEXT("PixoVRCharacter::BeginPlay DeviceName = %s"), *DeviceName.ToString());
    
    if (DeviceName == "SteamVR") // VIVE
    {
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);
    }
    else if (DeviceName == "OculusHMD") // Oculus
    {
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Eye);
        VRProxyComponent->AddLocalOffset(FVector(0.0f, 0.0f, DefaultPlayerHeight));
    }
    else if (DeviceName == "WaveVR") // FOCUS PLUS
    {
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);
    }
    else if (DeviceName == "PICOXRHMD") // PICO NEO
    {
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);
    }
    else if (DeviceName.ToString().Contains("Monado"))
    {
        FBPVRControllerProfile ControllerProfile;
        UVRGlobalSettings::GetControllerProfile("VRX", ControllerProfile);
        UVRGlobalSettings::LoadControllerProfile(ControllerProfile, true);
        
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);  
        VRProxyComponent->AddLocalOffset(FVector(0.0f, 0.0f, 15.f));
    }
    else // Windows
    {
// default to quest setup, unless compiling on windows
// this is for unknown headsets like the VRX
#if PLATFORM_WINDOWS
        // default to windows
        ActivateFPSMode(true);
#else
        // ...or default to oculus 
        UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);
        // VRProxyComponent->AddLocalOffset(FVector(0.0f, 0.0f, DefaultPlayerHeight));
#endif
    }
}
 
void APixoVRCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    if(TeleportControllerRight)
    {
        TeleportControllerRight->UpdateMotionControllerRotation(LastTeleportLeftDirectionVector);
    }
 
    if(TeleportControllerLeft)
    {
        TeleportControllerLeft->UpdateMotionControllerRotation(LastTeleportRightDirectionVector);
    }
    
    if(GetLocalRole() == ROLE_Authority)
    {
        // Do Wrist Menu related stuff.
        if(WristMenu)
        {
            if(WristMenu->IsActivated())
            {
                FVector2D PadPosition = FVector2D::ZeroVector;
                FVector2D Tmp;
                if (CurrentWristMenuHand == EControllerHand::Left)
                {
                    Tmp = FVector2D(LastTeleportLeftDirectionVector.X, LastTeleportLeftDirectionVector.Y);  
                }
                else
                {
                    Tmp = FVector2D(LastTeleportRightDirectionVector.X, LastTeleportRightDirectionVector.Y);
                }
                PadPosition = Tmp;
                WristMenu->UpdateTrackpadPosition(PadPosition);
            }
        }
    }
}
 
void APixoVRCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
 
    if (InputsTable)
    {
        InputAdapter->ResolveMappings(InputsTable);
    }
    else
    {
        UE_LOG(LogPixoVRCharacter, Warning, TEXT("PixoVRCharacter::InputsTable not set!"));
    }
    
    PlayerInputComponent->BindAxis("MoveForward", this, &APixoVRCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &APixoVRCharacter::MoveRight);
    PlayerInputComponent->BindAxis("Turn", this, &APixoVRCharacter::TurnAtRate);
    PlayerInputComponent->BindAxis("LookUp", this, &APixoVRCharacter::LookUpAtRate);
    
    PlayerInputComponent->BindAction("TeleportLeft", IE_Pressed, this, &APixoVRCharacter::HandleTeleportLeftPressed);
    PlayerInputComponent->BindAction("TeleportLeft", IE_Released, this, &APixoVRCharacter::HandleTeleportLeftReleased);
    PlayerInputComponent->BindAction("TeleportRight", IE_Pressed, this, &APixoVRCharacter::HandleTeleportRightPressed);
    PlayerInputComponent->BindAction("TeleportRight", IE_Released, this, &APixoVRCharacter::HandleTeleportRightReleased);
 
    PlayerInputComponent->BindAxis("TeleportLeftByAxis", this, &APixoVRCharacter::HandleTeleportLeftByAxis);
    PlayerInputComponent->BindAxis("TeleportRightByAxis", this, &APixoVRCharacter::HandleTeleportRightByAxis);
    
    PlayerInputComponent->BindAxis("MotionControllerThumbLeft_Y", this, &APixoVRCharacter::HandleTeleportLeftUp);
    PlayerInputComponent->BindAxis("MotionControllerThumbLeft_X", this, &APixoVRCharacter::HandleTeleportLeftRight);
    PlayerInputComponent->BindAxis("MotionControllerThumbRight_Y", this, &APixoVRCharacter::HandleTeleportRightUp);
    PlayerInputComponent->BindAxis("MotionControllerThumbRight_X", this, &APixoVRCharacter::HandleTeleportRightRight);
 
    PlayerInputComponent->BindAction("LaserBeamLeft", IE_Pressed, this, &APixoVRCharacter::HandleLaserBeamLeftPressed);
    PlayerInputComponent->BindAction("LaserBeamRight", IE_Pressed, this, &APixoVRCharacter::HandleLaserBeamRightPressed);
 
    PlayerInputComponent->BindAction("LaserSelectUILeft", IE_Pressed, this, &APixoVRCharacter::HandleLaserSelectLeft);
    PlayerInputComponent->BindAction("LaserSelectUILeft", IE_Released, this, &APixoVRCharacter::HandleLaserReleaseLeft);
    PlayerInputComponent->BindAction("LaserSelectUIRight", IE_Pressed, this, &APixoVRCharacter::HandleLaserSelectRight);
    PlayerInputComponent->BindAction("LaserSelectUIRight", IE_Released, this, &APixoVRCharacter::HandleLaserReleaseRight);
 
    PlayerInputComponent->BindAction("PCToggleWristMenu", IE_Pressed, this, &APixoVRCharacter::HandleActivateWristMenuPressedLeft);
    PlayerInputComponent->BindAction("ActivateWristMenu", IE_Pressed, this, &APixoVRCharacter::HandleActivateWristMenuPressed);
    PlayerInputComponent->BindAction("SelectWristMenuItemLeft", IE_Pressed, this, &APixoVRCharacter::HandleSelectWristMenuItemPressedLeft);
    PlayerInputComponent->BindAction("SelectWristMenuItemRight", IE_Pressed, this, &APixoVRCharacter::HandleSelectWristMenuItemPressedRight);
    PlayerInputComponent->BindAction("DoubleTapWristMenu", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuDoubleTap);
 
    PlayerInputComponent->BindAction("SelectWristMenuItem1", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem1Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem2", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem2Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem3", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem3Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem4", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem4Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem5", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem5Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem6", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem6Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem7", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem7Pressed);
    PlayerInputComponent->BindAction("SelectWristMenuItem8", IE_Pressed, this, &APixoVRCharacter::HandleWristMenuItem8Pressed);
 
    PlayerInputComponent->BindAction("GrabLeft", IE_Pressed, this, &APixoVRCharacter::GrabLeftPressed);
    PlayerInputComponent->BindAction("GrabLeft", IE_Released, this, &APixoVRCharacter::GrabLeftReleased);
    PlayerInputComponent->BindAction("GrabRight", IE_Pressed, this, &APixoVRCharacter::GrabRightPressed);
    PlayerInputComponent->BindAction("GrabRight", IE_Released, this, &APixoVRCharacter::GrabRightReleased);
 
    PlayerInputComponent->BindAction("HintActivated", IE_Pressed, this, &APixoVRCharacter::ActivateHint);
    
    PlayerInputComponent->BindAction("TurnVRLeft", IE_Pressed, this, &APixoVRCharacter::TurnVRLeft);
    PlayerInputComponent->BindAction("TurnVRRight", IE_Pressed, this, &APixoVRCharacter::TurnVRRight);
    PlayerInputComponent->BindAxis("TurnVRByAxis", this, &APixoVRCharacter::TurnVRByAxis);
}
 
void APixoVRCharacter::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(APixoVRCharacter, bIsOverWidgetUse);
    DOREPLIFETIME(APixoVRCharacter, LaserControllerLeft);
    DOREPLIFETIME(APixoVRCharacter, LaserControllerRight);
    DOREPLIFETIME(APixoVRCharacter, bActivateLeftLaser);
    DOREPLIFETIME(APixoVRCharacter, bActivateRightLaser);
    DOREPLIFETIME(APixoVRCharacter, WristMenu);
    DOREPLIFETIME(APixoVRCharacter, bTeleporterEnabled);
    DOREPLIFETIME(APixoVRCharacter, CurrentWristMenuHand);
    DOREPLIFETIME(APixoVRCharacter, TeleportControllerLeft);
    DOREPLIFETIME(APixoVRCharacter, TeleportControllerRight);
    DOREPLIFETIME(APixoVRCharacter, ProgressBar);
}
 
void APixoVRCharacter::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);
 
    // Spawn hands
    const FAttachmentTransformRules HandTransformRule = FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false);
    FActorSpawnParameters ActorSpawnParameters = {};
    ActorSpawnParameters.Owner = this;
    ActorSpawnParameters.Instigator = this;
    
    VRHandLeft = GetWorld()->SpawnActor<APixoVRHand>(VRHandClass, ActorSpawnParameters);
    VRHandLeft->InitPixoVRHands(EControllerHand::Left, this);
    VRHandLeft->AttachToComponent(VRProxyComponent, HandTransformRule);
    VRHandLeft->MotionController->AddTickPrerequisiteComponent(GetCharacterMovement());
    VRHandLeft->MotionController->OverrideSendTransform = &AVRBaseCharacter::Server_SendTransformLeftController;
    
    VRHandRight = GetWorld()->SpawnActor<APixoVRHand>(VRHandClass, ActorSpawnParameters);
    VRHandRight->InitPixoVRHands(EControllerHand::Right, this);
    VRHandRight->AttachToComponent(VRProxyComponent, HandTransformRule);
    VRHandRight->MotionController->AddTickPrerequisiteComponent(GetCharacterMovement());
    VRHandRight->MotionController->OverrideSendTransform = &AVRBaseCharacter::Server_SendTransformRightController;
 
    // We will spawn the tools on the server when the character gets possessed by a new controller. 
    SpawnTeleporter(EControllerHand::Left, true);
    SpawnTeleporter(EControllerHand::Right, true);
 
    SpawnLaserBeam(EControllerHand::Left, bLeftLaserBeamIsActiveOnStart);
    SpawnLaserBeam(EControllerHand::Right, bRightLaserBeamIsActiveOnStart);
    
    SpawnWristMenu();
    SpawnProgressBar();
}
 
void APixoVRCharacter::HandleTeleportLeftPressed()
{
    if(!CanTeleport())
    {
        return;
    }
 
    ActivateTeleporter(EControllerHand::Left, true);
}
 
void APixoVRCharacter::HandleTeleportLeftReleased()
{
    if(!CanTeleport() || !TeleportControllerLeft->IsActivated())
    {
        return;
    }
 
    ExecuteTeleportation(EControllerHand::Left);
}
 
void APixoVRCharacter::HandleTeleportRightPressed()
{
    if(!CanTeleport())
    {
        return;
    }
 
    ActivateTeleporter(EControllerHand::Right, true);
}
 
void APixoVRCharacter::HandleTeleportRightReleased()
{
    if (!CanTeleport() || !TeleportControllerRight->IsActivated())
    {
        return;
    }
 
    ExecuteTeleportation(EControllerHand::Right);
}
 
void APixoVRCharacter::HandleTeleportLeftByAxis(float CurrentAxisValue)
{
    static bool IsLeftTeleportActivatedByFunc = false;
    
    if (CurrentAxisValue > 0.f && !TeleportControllerLeft->IsActivated())
    {
        if(!CanTeleport())
        {
            return;
        }
 
        IsLeftTeleportActivatedByFunc = true;
        ActivateTeleporter(EControllerHand::Left, true);
    }
    else if (CurrentAxisValue <= 0.f && IsLeftTeleportActivatedByFunc)
    {
        IsLeftTeleportActivatedByFunc = false;
        
        if (!CanTeleport() || !TeleportControllerLeft->IsActivated())
        {
            return;
        }
 
        ExecuteTeleportation(EControllerHand::Left);
    }
}
 
void APixoVRCharacter::HandleTeleportRightByAxis(float CurrentAxisValue)
{
    static bool IsRightTeleportActivatedByFunc = false;
    
    if (CurrentAxisValue > 0.f && !TeleportControllerRight->IsActivated())
    {
        if(!CanTeleport())
        {
            return;
        }
 
        IsRightTeleportActivatedByFunc = true;
        ActivateTeleporter(EControllerHand::Right, true);
    }
    else if (CurrentAxisValue <= 0.f && IsRightTeleportActivatedByFunc)
    {
        IsRightTeleportActivatedByFunc = false;
        
        if (!CanTeleport() || !TeleportControllerRight->IsActivated())
        {
            return;
        }
 
        ExecuteTeleportation(EControllerHand::Right);
    }
}
 
bool APixoVRCharacter::CanTeleport() const
{
    return !((WristMenu && WristMenu->IsActivated()) || bTeleporterEnabled == false);
}
 
void APixoVRCharacter::ExecuteTeleportation(EControllerHand Hand)
{
    ATeleporterBase* TeleportController = nullptr;
    
    switch(Hand)
    {
        case EControllerHand::Left: TeleportController = TeleportControllerLeft; break;
        case EControllerHand::Right: TeleportController = TeleportControllerRight; break;
    }
 
    // Either no TeleportController class was specified, means the user didn't want to use
    // a Teleporter at all, or we received a wrong Hand enum which should not happen. 
    if(!TeleportController) return;
    
    // Execute the teleportation.
    TeleportController->ExecuteTeleportation(VRMovementReference, GetActorTransform(), GetVRLocation(), GetActorRotation());
    // Disable the Teleporter.
    ActivateTeleporter(Hand, false);
}
 
void APixoVRCharacter::ActivateTeleporter(EControllerHand Hand, bool InActivate)
{
    OnTeleportationActivated().Broadcast(Hand, InActivate);
    
    switch(Hand)
    {
    case EControllerHand::Left:
        {
            if(TeleportControllerLeft)
            {
                TeleportControllerLeft->ActivateTeleporter(InActivate);
            }
        }
        break;
    case EControllerHand::Right:
        {
            if(TeleportControllerRight)
            {
                TeleportControllerRight->ActivateTeleporter(InActivate);
            }
        }
        break;
    default:
        break;
    }
 
    NotifyActivateTeleporter(Hand, InActivate);
}
 
void APixoVRCharacter::SpawnTeleporter(EControllerHand Hand, bool InActivate)
{
    const FAttachmentTransformRules AttachmentTransformRules(EAttachmentRule::SnapToTarget, EAttachmentRule::SnapToTarget, EAttachmentRule::KeepWorld,  false);
    FActorSpawnParameters ActorSpawnParameters = {};
    ActorSpawnParameters.Owner = this;
    ActorSpawnParameters.Instigator = this;
 
    switch (Hand)
    {
    case EControllerHand::Left:
        {
            if (TeleportControllerClass)
            {
                TeleportControllerLeft = GetWorld()->SpawnActor<ATeleporterBase>(TeleportControllerClass, ActorSpawnParameters);
                TeleportControllerLeft->SetMotionController(LeftMotionController);
 
                if (TeleportControllerLeft)
                {
                    if (VRHandLeft->HandMesh)
                    {
                        TeleportControllerLeft->AttachToComponent(VRHandLeft->HandMesh, AttachmentTransformRules, LeftTeleporterSocket);
                    }
                }
            }
        }
        break;
    case EControllerHand::Right:
        {
            if (TeleportControllerClass)
            {
                TeleportControllerRight = GetWorld()->SpawnActor<ATeleporterBase>(TeleportControllerClass, ActorSpawnParameters);
                TeleportControllerRight->SetMotionController(RightMotionController);
 
                if (TeleportControllerLeft)
                {
                    if (VRHandLeft->HandMesh)
                    {
                        TeleportControllerRight->AttachToComponent(VRHandRight->HandMesh, AttachmentTransformRules,  RightTeleporterSocket);
                    }
                }
            }
        }
        break;
    default: break;
    }
}
 
void APixoVRCharacter::SpawnNewTeleporterClass(TSubclassOf<ATeleporterBase> TeleporterClass)
{
    TeleportControllerClass = TeleporterClass;
 
    TeleportControllerLeft->Destroy();
    TeleportControllerRight->Destroy();
    
    SpawnTeleporter(EControllerHand::Left, true);
    SpawnTeleporter(EControllerHand::Right, true);
}
 
void APixoVRCharacter::MulticastActivateTeleporter_Implementation(EControllerHand Hand, bool InActivate)
{
    if(!IsLocallyControlled())
    {
        OnTeleportationActivated().Broadcast(Hand, InActivate);
        switch (Hand)
        {
        case EControllerHand::Left:
            {
                if(TeleportControllerLeft)
                {
                    TeleportControllerLeft->ActivateTeleporter(InActivate);
                }
            }
            break;
        case EControllerHand::Right:
            {
                if(TeleportControllerRight)
                {
                    TeleportControllerRight->ActivateTeleporter(InActivate);
                }
            }
            break;
        default:
            break;
        }
    }
}
 
void APixoVRCharacter::NotifyActivateTeleporter_Implementation(EControllerHand Hand, bool InActivate)
{
    MulticastActivateTeleporter(Hand, InActivate);
}
 
bool APixoVRCharacter::NotifyActivateTeleporter_Validate(EControllerHand Hand, bool InActivate)
{
    return true;
}
 
void APixoVRCharacter::HandleLaserBeamLeftPressed()
{
    // Are we going to use the Laser-beam at all?
    if(!LaserControllerClass)
    {
        // No, just don't do anything.
        return;
    }
    
    if (VRHandLeft->HandHoldingObject)
    {
        return;
    }
    
    if (LaserControllerRight && LaserControllerRight->bIsLaserBeamActive)
    {
        bLaserBeamActive = true;
        ActivateLaserBeam(EControllerHand::Right, false);
 
        if (VRHandRight->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandRight->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        }
    }
    else
    {
        bLaserBeamActive = !bLaserBeamActive;
    }
 
    ActivateLaserBeam(EControllerHand::Left, bLaserBeamActive);
 
    if (VRHandLeft->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        if (bLaserBeamActive)
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandLeft->HandMesh->GetAnimInstance(), EPixoVRGripState::HoldLaserPointer);
        }
        else
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandLeft->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        }
    }
}
 
void APixoVRCharacter::HandleLaserBeamRightPressed()
{
    // Are we going to use the Laser-beam at all?
    if(!LaserControllerClass)
    {
        // No, just don't do anything.
        return;
    }
    
    if (VRHandRight->HandHoldingObject)
    {
        return;
    }
 
    if (LaserControllerLeft && LaserControllerLeft->bIsLaserBeamActive)
    {
        bLaserBeamActive = true;
        ActivateLaserBeam(EControllerHand::Left, false);
 
        if (VRHandLeft->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandLeft->HandMesh->GetAnimInstance(),
                                                              EPixoVRGripState::Open);
        }
    }
    else
    {
        bLaserBeamActive = !bLaserBeamActive;
    }
 
    ActivateLaserBeam(EControllerHand::Right, bLaserBeamActive);
 
    if (VRHandRight->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        if (bLaserBeamActive)
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandRight->HandMesh->GetAnimInstance(), EPixoVRGripState::HoldLaserPointer);
        }
        else
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(VRHandRight->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        }
    }
}
 
void APixoVRCharacter::IsLaserActivated(bool& IsActivated, EControllerHand& Hand)
{
    IsActivated = bLaserBeamActive;
    Hand = bActivateLeftLaser ? EControllerHand::Left : EControllerHand::Right;
}
 
void APixoVRCharacter::IsOverWidgetUse_Implementation(EControllerHand Hand, bool InPressed)
{
    PerformIsOverWidgetUse(Hand, InPressed);
}
 
void APixoVRCharacter::PerformIsOverWidgetUse_Implementation(EControllerHand Hand, bool InPressed)
{
    bIsOverWidgetUse = false;
 
    switch(Hand)
    {
    case EControllerHand::Left:
        {
            if(LaserControllerLeft)
            {
                bIsOverWidgetUse = LaserControllerLeft->IsOverWidgetUse(InPressed);
            }
        }
        break;
    case EControllerHand::Right:
        {
            if(LaserControllerRight)
            {
                bIsOverWidgetUse = LaserControllerRight->IsOverWidgetUse(InPressed);
            }
        }
        break;
    default: break;
    }
}
 
bool APixoVRCharacter::IsOverWidgetUse_Validate(EControllerHand Hand, bool InPressed)
{
    return true;
}
 
void APixoVRCharacter::SpawnLaserBeam(EControllerHand Hand, bool InActivate)
{
    const FAttachmentTransformRules AttachmentTransformRules(EAttachmentRule::SnapToTarget, EAttachmentRule::SnapToTarget, EAttachmentRule::SnapToTarget, true);
    FActorSpawnParameters ActorSpawnParameters = {};
    ActorSpawnParameters.Owner = this;
    ActorSpawnParameters.Instigator = this;
 
    switch(Hand)
    {
    case EControllerHand::Left: 
        {
            if(LaserControllerClass)
            {
                LaserControllerLeft = GetWorld()->SpawnActor<APixoVRLaser>(LaserControllerClass, ActorSpawnParameters);
                LaserControllerLeft->SetHandType(EControllerHand::Left, IsLocallyControlled());
                LaserControllerLeft->AttachToComponent(VRHandLeft->HandMesh, AttachmentTransformRules, LeftLaserBeamSocket);
                LaserControllerLeft->WidgetInteraction->PointerIndex = 0;
                
                if(InActivate)
                {
                    HandleLaserBeamLeftPressed();
                }
            }
        }
        break;
    case EControllerHand::Right: 
        {
            if(LaserControllerClass)
            {
                LaserControllerRight = GetWorld()->SpawnActor<APixoVRLaser>(LaserControllerClass, ActorSpawnParameters);
                LaserControllerRight->SetHandType(EControllerHand::Right, IsLocallyControlled());
                LaserControllerRight->AttachToComponent(VRHandRight->HandMesh, AttachmentTransformRules, RightLaserBeamSocket);
                LaserControllerRight->WidgetInteraction->PointerIndex = 1;
                
                if(InActivate)
                {
                    HandleLaserBeamRightPressed();
                }
            }
        }
        break;
    default: break;
    }
}
 
void APixoVRCharacter::HandleLaserSelectLeft()
{
    if (bActivateLeftLaser)
    {
        IsOverWidgetUse(EControllerHand::Left, true);
 
        HandleLaserSelectEvent(EControllerHand::Left, true);
    }
}
 
void APixoVRCharacter::HandleLaserReleaseLeft()
{
    if (bActivateLeftLaser)
    {
        IsOverWidgetUse(EControllerHand::Left, false);
 
        HandleLaserSelectEvent(EControllerHand::Left, false);
    }
}
 
void APixoVRCharacter::HandleLaserSelectRight()
{
    if (bActivateRightLaser)
    {
        IsOverWidgetUse(EControllerHand::Right, true);
 
        HandleLaserSelectEvent(EControllerHand::Right, true);
    }
}
 
void APixoVRCharacter::HandleLaserReleaseRight()
{
    if (bActivateRightLaser)
    {
        IsOverWidgetUse(EControllerHand::Right, false);
 
        HandleLaserSelectEvent(EControllerHand::Right, false);
    }
}
 
void APixoVRCharacter::HandleLaserSelectEvent_Implementation(EControllerHand Hand, bool Pressed)
{
    MultiHandleLaserSelectEvent(Hand, Pressed);
}
 
void APixoVRCharacter::MultiHandleLaserSelectEvent_Implementation(EControllerHand Hand, bool Pressed)
{
    HandleLaserSelect(Hand, Pressed);
}
 
void APixoVRCharacter::HandleLaserSelect(EControllerHand Hand, bool Pressed)
{
    switch (Hand)
    {
    case EControllerHand::Left:
    {
        LaserControllerLeft->TriggerSelect(Pressed);
    }
    break;
    case EControllerHand::Right:
    {
        LaserControllerRight->TriggerSelect(Pressed);
    }
    break;
    default:
        break;
    }
}
 
void APixoVRCharacter::ActivateLaserBeam_Implementation(EControllerHand Hand, bool InActivate)
{
    switch (Hand)
    {
    case EControllerHand::Left:
        {
            VRHandLeft->ToggleLaser(InActivate);
 
            bActivateLeftLaser = InActivate;
            LaserControllerLeft->ActivateLaserBeam(bActivateLeftLaser);
        }
        break;
    case EControllerHand::Right:
        {
            VRHandRight->ToggleLaser(InActivate);
 
            bActivateRightLaser = InActivate;
            LaserControllerRight->ActivateLaserBeam(bActivateRightLaser);
        }
        break;
    default:
        break;
    }
 
    HandleHandAnimationLaser(Hand);
}
 
bool APixoVRCharacter::ActivateLaserBeam_Validate(EControllerHand Hand, bool InActivate)
{
    return true;
}
 
void APixoVRCharacter::ActivateFPSMode_Implementation(bool Enable)
{
    bFPSMode = Enable;
    
    if(bFPSMode)
    {
        VRHandLeft->AttachToComponent(VRReplicatedCamera, FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false));
        VRHandLeft->SetActorRelativeLocation(FVector(62.0f, -28.0f, -15.0f));
        
        VRHandRight->AttachToComponent(VRReplicatedCamera, FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false));
        VRHandRight->SetActorRelativeLocation(FVector(62.0f, 31.0f, -15.0f));
        
        bUseControllerRotationPitch = false;
 
        const auto MovementComponent = Cast<UVRCharacterMovementComponent>(GetMovementComponent());
        MovementComponent->bUseClientControlRotation = true;
        MovementComponent->bAllowMovementMerging = true;
 
        VRReplicatedCamera->bUsePawnControlRotation = true;
        VRReplicatedCamera->bLockToHmd = false;
        VRReplicatedCamera->bAutoSetLockToHmd = false;
    }
}
 
void APixoVRCharacter::TurnVRByAxis(float CurrentAxisValue)
{
    static float PreviousAxisValue = 0.f;
    
    if (CurrentAxisValue != 0.f)
    {
        if (CurrentAxisValue > 0.f && PreviousAxisValue <= 0.f)
            TurnVRRight();
        else if (CurrentAxisValue < 0.f && PreviousAxisValue >= 0.f)
            TurnVRLeft();
    }
        
    PreviousAxisValue = CurrentAxisValue;
}
 
void APixoVRCharacter::TurnVRLeft()
{
    if (!bRotationByControllerEnabled)
    {
        return;
    }
    
    AddActorWorldRotationVR(FRotator(0.0f, -DeflectionAngle, 0.0f));
    OnCameraRotatedByController.Broadcast(-DeflectionAngle);
}
 
void APixoVRCharacter::TurnVRRight()
{
    if (!bRotationByControllerEnabled)
    {
        return;
    }
    
    AddActorWorldRotationVR(FRotator(0.0f, DeflectionAngle, 0.0f));
    OnCameraRotatedByController.Broadcast(DeflectionAngle);
}
 
void APixoVRCharacter::MoveForward(float Value)
{
    AddMovementInput(GetVRForwardVector(), Value);
}
 
void APixoVRCharacter::MoveRight(float Value)
{
    AddMovementInput(GetVRRightVector(), Value);
}
 
void APixoVRCharacter::TurnAtRate(float Rate)
{
    AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
 
void APixoVRCharacter::LookUpAtRate(float Rate)
{
    AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
 
void APixoVRCharacter::GrabRightPressed()
{
    OnHandGrabAction.Broadcast(true, true);
    
    if (HoldToolLeft && VRHandLeft->HandHoldingObject && VRHandLeft->HandHoldingObject->Implements<UPixoVRStoryObject>() &&
    IPixoVRStoryObject::Execute_CouldBeGrabbedWithTwoHands(VRHandLeft->HandHoldingObject))
    {
        if (IPixoVRStoryObject::Execute_IsObjectHeldWithTwoHands(VRHandLeft->HandHoldingObject))
            IPixoVRStoryObject::Execute_ReleaseTwoHands(VRHandLeft->HandHoldingObject, VRHandRight->MotionController);
        else
            IPixoVRStoryObject::Execute_GrabWithTwoHands(VRHandLeft->HandHoldingObject, VRHandRight->MotionController);
        return;
    }
    
    if (HoldToolRight)
    {
        if (VRHandRight->HandHoldingObject && VRHandRight->HandHoldingObject->Implements<UPixoVRStoryObject>() &&
            IPixoVRStoryObject::Execute_ReleaseItemByPress(VRHandRight->HandHoldingObject))
        {
            ReleasedRightHand();
        }
 
        return;
    }
    
    VRHandRight->GrabObject();
 
    if(LaserControllerRight->bIsLaserBeamActive && VRHandRight->HandHoldingObject)
    {
        bLaserBeamActive = false;
        ActivateLaserBeam(EControllerHand::Right, false);
    }
    else if(LaserControllerRight->bIsLaserBeamActive)
    {
        return;
    }
    
    if (VRHandRight->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        EPixoVRGripState GripAnimation = EPixoVRGripState::Grab;
        
        if (VRHandRight->HandHoldingObject != nullptr)
        {
            if (VRHandRight->HandHoldingObject->GetClass()->ImplementsInterface(UGripResponseAnimationInterface::StaticClass()))
            {
                if (IGripResponseAnimationInterface::Execute_IsUsingCustomGripAnimation(VRHandRight->HandHoldingObject))
                {
                    GripAnimation = IGripResponseAnimationInterface::Execute_GetObjectGripAnimation(VRHandRight->HandHoldingObject);
                }
                else
                {
                    GripAnimation = EPixoVRGripState::AdvanceGrab;
                }
            }
            else
            {
                GripAnimation = EPixoVRGripState::AdvanceGrab;
            }
        }
        IHandAnimationInterface::Execute_SetAnimationGripState(VRHandRight->HandMesh->GetAnimInstance(), GripAnimation);
    }
}
 
void APixoVRCharacter::GrabLeftPressed()
{
    OnHandGrabAction.Broadcast(true, false);
    
    if (HoldToolRight && VRHandRight->HandHoldingObject && VRHandRight->HandHoldingObject->Implements<UPixoVRStoryObject>() &&
    IPixoVRStoryObject::Execute_CouldBeGrabbedWithTwoHands(VRHandRight->HandHoldingObject))
    {
        if (IPixoVRStoryObject::Execute_IsObjectHeldWithTwoHands(VRHandRight->HandHoldingObject))
            IPixoVRStoryObject::Execute_ReleaseTwoHands(VRHandRight->HandHoldingObject, VRHandLeft->MotionController);
        else
            IPixoVRStoryObject::Execute_GrabWithTwoHands(VRHandRight->HandHoldingObject, VRHandLeft->MotionController);
        return;
    }
    
    if (HoldToolLeft)
    {
        if (VRHandLeft->HandHoldingObject && VRHandLeft->HandHoldingObject->Implements<UPixoVRStoryObject>()
            && IPixoVRStoryObject::Execute_ReleaseItemByPress(VRHandLeft->HandHoldingObject))
        {
            ReleasedLeftHand();
        }
 
        return;
    }
    
    VRHandLeft->GrabObject();
    
    if(LaserControllerLeft->bIsLaserBeamActive && VRHandLeft->HandHoldingObject)
    {
        bLaserBeamActive = false;
        ActivateLaserBeam(EControllerHand::Left, false);
    }
    else if(LaserControllerLeft->bIsLaserBeamActive)
    {
        return;
    }
 
    if (VRHandLeft->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        EPixoVRGripState GripAnimation = EPixoVRGripState::Grab;
 
        if (VRHandLeft->HandHoldingObject != nullptr)
        {
            if (VRHandLeft->HandHoldingObject->GetClass()->ImplementsInterface(UGripResponseAnimationInterface::StaticClass()))
            {
                if (IGripResponseAnimationInterface::Execute_IsUsingCustomGripAnimation(VRHandLeft->HandHoldingObject))
                {
                    GripAnimation = IGripResponseAnimationInterface::Execute_GetObjectGripAnimation(VRHandLeft->HandHoldingObject);
                }
                else
                {
                    GripAnimation = EPixoVRGripState::AdvanceGrab;
                }
            }
            else
            {
                GripAnimation = EPixoVRGripState::AdvanceGrab;
            }
        }
        IHandAnimationInterface::Execute_SetAnimationGripState(VRHandLeft->HandMesh->GetAnimInstance(), GripAnimation);
    }
}
 
void APixoVRCharacter::ReleasedRightHand()
{
    if (VRHandRight->HandHoldingObject)
    {
        if (VRHandRight->HandHoldingObject->Implements<UPixoVRStoryObject>() &&
            IPixoVRStoryObject::Execute_DenyDropping(VRHandRight->HandHoldingObject))
        {
            return;
        }
        if (VRHandRight->HandHoldingObject->Implements<UPixoVRStoryObject>() &&
            IPixoVRStoryObject::Execute_HoldItemByClick(VRHandRight->HandHoldingObject) &&
            !HoldToolRight)
        {
            HoldToolRight = true;
            return;
        }
    }
 
    if (LaserControllerRight->bIsLaserBeamActive)
    {
        return;
    }
 
    if (HoldToolRight)
    {
        HoldToolRight = false;
    }
 
    VRHandRight->ReleaseObject();
 
    if (VRHandRight->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(
        UHandAnimationInterface::StaticClass()))
    {
        IHandAnimationInterface::Execute_SetAnimationGripState(VRHandRight->HandMesh->GetAnimInstance(),
                                                               EPixoVRGripState::Open);
    }
}
 
void APixoVRCharacter::ReleasedLeftHand()
{
    if (VRHandLeft->HandHoldingObject)
    {
        if (VRHandLeft->HandHoldingObject->Implements<UPixoVRStoryObject>()
            && IPixoVRStoryObject::Execute_DenyDropping(VRHandLeft->HandHoldingObject))
        {
            return;
        }
        if (VRHandLeft->HandHoldingObject->Implements<UPixoVRStoryObject>()
            && IPixoVRStoryObject::Execute_HoldItemByClick(VRHandLeft->HandHoldingObject) && !HoldToolLeft)
        {
            HoldToolLeft = true;
            return;
        }
    }
 
    if(LaserControllerLeft->bIsLaserBeamActive)
    {
        return;
    }
 
    if (HoldToolLeft)
    {
        HoldToolLeft = false;
    }
 
    VRHandLeft->ReleaseObject();
 
    if(VRHandLeft->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        IHandAnimationInterface::Execute_SetAnimationGripState(VRHandLeft->HandMesh->GetAnimInstance(),EPixoVRGripState::Open);
    }
}
 
void APixoVRCharacter::GrabRightReleased()
{
    OnHandGrabAction.Broadcast(false, true);
 
    if (VRHandRight->HandHoldingObject && VRHandRight->HandHoldingObject->Implements<UPixoVRStoryObject>()
        && IPixoVRStoryObject::Execute_ReleaseItemByPress(VRHandRight->HandHoldingObject))
    {
        if (!HoldToolRight)
        {
            HoldToolRight = true;
        }
    }
    else
    {
        ReleasedRightHand();
    }
}
 
void APixoVRCharacter::GrabLeftReleased()
{
    OnHandGrabAction.Broadcast(false, false);
 
    if (VRHandLeft->HandHoldingObject && VRHandLeft->HandHoldingObject->Implements<UPixoVRStoryObject>()
        && IPixoVRStoryObject::Execute_ReleaseItemByPress(VRHandLeft->HandHoldingObject))
    {
        if (!HoldToolLeft)
        {
            HoldToolLeft = true;
        }
    }
    else
    {
        ReleasedLeftHand();
    }
    
}
 
AActor* APixoVRCharacter::SpawnActorInHand(TSubclassOf<AActor> ActorClass, bool RightHand)
{
    APixoVRHand* HandRef = RightHand ? VRHandRight : VRHandLeft;
    if (HandRef->HandHoldingObject)
    {
        UE_LOG(LogTemp, Error, TEXT("APixoVRCharacter - Can't spawn object in the hand"));
        return nullptr;
    }
    
    AActor* SpawnedActor = GetWorld()->SpawnActor(ActorClass);
    APixoVRLaser* LaserRef = RightHand ? LaserControllerRight : LaserControllerLeft;
    EControllerHand ActiveHand = RightHand ? EControllerHand::Right : EControllerHand::Left;
 
    HandRef->ManuallyPutActorToHand(SpawnedActor);
    
    if(LaserRef->bIsLaserBeamActive)
    {
        bLaserBeamActive = false;
        ActivateLaserBeam(ActiveHand, false);
    }
 
    if (SpawnedActor->Implements<UPixoVRStoryObject>() && IPixoVRStoryObject::Execute_HoldItemByClick(SpawnedActor) && !(RightHand ? HoldToolRight : HoldToolRight))
    {
        if (RightHand)
            HoldToolRight = true;
        else
            HoldToolLeft = true;
    }
    
    auto ChangeAnimation = [=]()
    {
        if (HandRef->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        {
            EPixoVRGripState GripAnimation = EPixoVRGripState::Grab;
        
            if (SpawnedActor != nullptr)
            {
                if (SpawnedActor->GetClass()->ImplementsInterface(UGripResponseAnimationInterface::StaticClass()))
                {
                    if (IGripResponseAnimationInterface::Execute_IsUsingCustomGripAnimation(SpawnedActor))
                    {
                        GripAnimation = IGripResponseAnimationInterface::Execute_GetObjectGripAnimation(SpawnedActor);
                    }
                    else
                    {
                        GripAnimation = EPixoVRGripState::AdvanceGrab;
                    }
                }
                else
                {
                    GripAnimation = EPixoVRGripState::AdvanceGrab;
                }
            }
            IHandAnimationInterface::Execute_SetAnimationGripState(HandRef->HandMesh->GetAnimInstance(), GripAnimation);
        }
    };
    FTimerDelegate TimerDelegate;
    TimerDelegate.BindLambda(ChangeAnimation);
    GetWorldTimerManager().SetTimerForNextTick(TimerDelegate);
    return SpawnedActor;
}
 
void APixoVRCharacter::ResetHandHoldingObject()
{
    if (VRHandLeft->HandHoldingObject)
    {
        GrabLeftReleased();
    }
    else if (VRHandRight->HandHoldingObject)
    {
        GrabRightReleased();
    }
}
 
void APixoVRCharacter::ResetHand(bool RightHand)
{
    APixoVRHand* HandToReset = RightHand ? VRHandRight : VRHandLeft;
    RightHand ? HoldToolRight = false : HoldToolLeft = false;
    
    if (HandToReset->HandHoldingObject)
        HandToReset->ReleaseObject();
    
    if(HandToReset->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        IHandAnimationInterface::Execute_SetAnimationGripState(HandToReset->HandMesh->GetAnimInstance(),EPixoVRGripState::Open);
}
 
void APixoVRCharacter::ShowTool(EControllerHand Hand, AActor* Tool)
{
    const FAttachmentTransformRules AttachmentTransformRules(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
    
    switch(Hand)
    {
    case EControllerHand::Left:
        Tool->SetActorLocation(VRHandLeft->HandMesh->GetSocketLocation(ToolSocket));
        VRHandLeft->GrabObject();
        break;
    case EControllerHand::Right:
        Tool->SetActorLocation(VRHandRight->HandMesh->GetSocketLocation(ToolSocket));
        VRHandRight->GrabObject();
        break;
    }
}
 
void APixoVRCharacter::DeactivateHint()
{
    if (HintManager)
    {
        HintManager->HintActivated(false);
    }
    else
        UE_LOG(LogTemp, Error, TEXT("HintManager isn't initialized"));
}
 
void APixoVRCharacter::ActivateHint()
{
    if (HintManager)
    {
        HintManager->HintActivated(true);
    }
    else
        UE_LOG(LogTemp, Error, TEXT("HintManager isn't initialized"));
}
 
void APixoVRCharacter::PlayerDestroyed(AActor* Act)
{
    if (LaserControllerRight)
    {
        LaserControllerRight->Destroy();
    }
    
    if (LaserControllerLeft)
    {
        LaserControllerLeft->Destroy();
    }
 
    if (WristMenu)
    {
        WristMenu->Destroy();
    }
 
    if(TeleportControllerRight && TeleportControllerRight->IsActivated())
    {
        TeleportControllerRight->ActivateTeleporter(false);
    }
 
    if(TeleportControllerLeft && TeleportControllerLeft->IsActivated())
    {
        TeleportControllerLeft->ActivateTeleporter(false);
    }
}
 
void APixoVRCharacter::HandleTeleportRightRight_Implementation(float Value)
{
    LastTeleportRightDirectionVector.X = Value;
}
 
bool APixoVRCharacter::HandleTeleportRightRight_Validate(float Value)
{
    return true;
}
 
void APixoVRCharacter::HandleTeleportRightUp_Implementation(float Value)
{
    LastTeleportRightDirectionVector.Y = Value;
}
 
bool APixoVRCharacter::HandleTeleportRightUp_Validate(float Value)
{
    return true;
}
 
void APixoVRCharacter::HandleTeleportLeftRight_Implementation(float Value)
{
    LastTeleportLeftDirectionVector.X = Value;
}
 
bool APixoVRCharacter::HandleTeleportLeftRight_Validate(float Value)
{
    return true;
}
 
void APixoVRCharacter::HandleTeleportLeftUp_Implementation(float Value)
{
    LastTeleportLeftDirectionVector.Y = Value;
}
 
bool APixoVRCharacter::HandleTeleportLeftUp_Validate(float Value)
{
    return true;
}
 
void APixoVRCharacter::HandleActivateWristMenuPressedLeft()
{
    ActivateWristMenu(EControllerHand::Left);
}
 
void APixoVRCharacter::HandleActivateWristMenuPressedRight()
{
    ActivateWristMenu(EControllerHand::Right);
}
 
void APixoVRCharacter::HandleWristMenuDoubleTap(FKey InputKey)
{
    if (LastPressedKey == InputKey)
    {
        HandleSelectWristMenuItemPressed();
    }
    else
    {
        LastPressedKey = InputKey;
    }
}
 
void APixoVRCharacter::SpawnProgressBar_Implementation()
{
    const FAttachmentTransformRules ProgressBarAttachmentTransformRules(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
    FActorSpawnParameters ActorSpawnParameters = {};
    
    ActorSpawnParameters.Owner = this;
    ActorSpawnParameters.Instigator = this;
 
    if (ProgressBar)
    {
        ProgressBar = GetWorld()->SpawnActor<APixoVRCircleProgress>(ProgressBarClass, ActorSpawnParameters);
        ProgressBar->AttachToComponent(VRHandLeft->HandMesh, ProgressBarAttachmentTransformRules, WristMenuSocket);
    }
}
 
bool APixoVRCharacter::SpawnProgressBar_Validate()
{
    return true;
}
 
void APixoVRCharacter::SpawnWristMenu_Implementation()
{
    if(WristMenuClass)
    {
        const FAttachmentTransformRules WristMenuAttachmentTransformRules(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
 
        FActorSpawnParameters ActorSpawnParameters = {};
        ActorSpawnParameters.Owner = this;
        ActorSpawnParameters.Instigator = this;
        
        WristMenu = GetWorld()->SpawnActor<APixoVRWristMenu>(WristMenuClass, ActorSpawnParameters);
        WristMenu->AttachToComponent(VRHandLeft->HandMesh, WristMenuAttachmentTransformRules, WristMenuSocket);
    }
}
 
bool APixoVRCharacter::SpawnWristMenu_Validate()
{
    return true;
}
 
void APixoVRCharacter::ActivateProgressBar_Implementation(EControllerHand Hand, bool InActivate)
{
    const auto CurrentHand = Hand == EControllerHand::Left ? VRHandLeft->HandMesh : VRHandRight->HandMesh;
    
    const FAttachmentTransformRules ProgressBarAttachment(EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, EAttachmentRule::KeepRelative, true);
 
    if (ProgressBar)
    {
        ProgressBar->AttachToComponent(CurrentHand, ProgressBarAttachment, WristMenuSocket);
        ProgressBar->SetActorScale3D(Hand == EControllerHand::Left ? FVector(1) : MirroredWristMenuScale);
        ProgressBar->SetCircleProgressEnabled(InActivate);
    }
}
 
bool APixoVRCharacter::ActivateProgressBar_Validate(EControllerHand Hand, bool InActivate)
{
    return true;
}
 
void APixoVRCharacter::ActivateWristMenu_Implementation(EControllerHand Hand)
{
    if (!WristMenu)
    {
        return;
    }
 
    ActivateProgressBar(Hand, false);
    LastPressedKey = "None";
 
    const auto CurrentHand = Hand == EControllerHand::Left ? VRHandLeft->HandMesh : VRHandRight->HandMesh;
 
    const FAttachmentTransformRules WristMenuAttachmentTransformRules(EAttachmentRule::KeepRelative,
                                                                      EAttachmentRule::KeepRelative,
                                                                      EAttachmentRule::KeepRelative, true);
 
    const auto PlatformName = UGameplayStatics::GetPlatformName();
 
    if (PlatformName == "Windows" || PlatformName == "Mac" || PlatformName == "Linux")
    {
        WristMenu->AttachToComponent(WristMenuLoc, WristMenuAttachmentTransformRules);
        WristMenu->bAlignToPlayerHead = true;
    }
    else
    {
        WristMenu->AttachToComponent(CurrentHand, WristMenuAttachmentTransformRules, WristMenuSocket);
    }
 
    // Mirror wrist if it is for right hand, as left hand was default before.
    if (Hand == EControllerHand::Left)
    {
        WristMenu->SetActorScale3D(FVector(1));
    }
    else
    {
        WristMenu->SetActorScale3D(MirroredWristMenuScale);
    }
 
    if (WristMenu->IsActivated())
    {
        if (CurrentWristMenuHand == Hand)
        {
            WristMenu->ActivateWristMenu(false);
        }
    }
    else
    {
        WristMenu->ActivateWristMenu(true);
    }
 
    CurrentWristMenuHand = Hand;
 
    OnWristMenuActivated.Broadcast(Hand);
}
 
bool APixoVRCharacter::ActivateWristMenu_Validate(EControllerHand Hand)
{
    return true;
}
 
void APixoVRCharacter::HandleActivateWristMenuPressed()
{
    ActivateWristMenu(EControllerHand::Left);
}
 
void APixoVRCharacter::HandleSelectWristMenuItemPressed()
{
    if (!WristMenuClass || !WristMenu || !WristMenu->IsActivated())
    {
        return;
    }
 
    LastPressedKey = "None";
    if(EWristMenuItemCategory::EXECUTETABLE == WristMenu->SelectMenuItem())
    {
        ActivateWristMenu(CurrentWristMenuHand);
    }
}
 
void APixoVRCharacter::SelectWristMenu(EControllerHand Hand)
{
    if(Hand == CurrentWristMenuHand)
    {
        HandleSelectWristMenuItemPressed();
    }
}
 
void APixoVRCharacter::HandleSelectWristMenuItemPressedLeft()
{
    if (EControllerHand::Left == CurrentWristMenuHand)
    {
        HandleSelectWristMenuItemPressed();
    }
}
 
void APixoVRCharacter::HandleSelectWristMenuItemPressedRight()
{
    if (EControllerHand::Right == CurrentWristMenuHand)
    {
        HandleSelectWristMenuItemPressed();
    }
}
 
void APixoVRCharacter::HandleWristMenuItem1Pressed()
{
    WristMenu->CalculateRotationByItemIndex(0);
}
 
void APixoVRCharacter::HandleWristMenuItem2Pressed()
{
    WristMenu->CalculateRotationByItemIndex(1);
}
 
void APixoVRCharacter::HandleWristMenuItem3Pressed()
{
    WristMenu->CalculateRotationByItemIndex(2);
}
 
void APixoVRCharacter::HandleWristMenuItem4Pressed()
{
    WristMenu->CalculateRotationByItemIndex(3);
}
 
void APixoVRCharacter::HandleWristMenuItem5Pressed()
{
    WristMenu->CalculateRotationByItemIndex(4);
}
 
void APixoVRCharacter::HandleWristMenuItem6Pressed()
{
    WristMenu->CalculateRotationByItemIndex(5);
}
 
void APixoVRCharacter::HandleWristMenuItem7Pressed()
{
    WristMenu->CalculateRotationByItemIndex(6);
}
 
void APixoVRCharacter::HandleWristMenuItem8Pressed()
{
    WristMenu->CalculateRotationByItemIndex(7);
}