PixoVRCharacter.h

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "VRCharacter.h"
#include "PixoVRHand.h"
#include "Managers/HintManager.h"
#include "PixoVRCharacter.generated.h"
 
class UPixoVRLongHoldComponent;
class UPixoVRInputAdapter;
class APixoVRCircleProgress;
class APixoVRWristMenu;
class UDataTable;
class USphereComponent;
class APixoVRLaser;
class UPixoVRMotionControllerComponent;
class APixoVRTeleporter;
 
DECLARE_LOG_CATEGORY_EXTERN(LogPixoVRCharacter, Log, All);
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnTeleportationActivated, EControllerHand, bool);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnWristMenuActivated, EControllerHand, Hand);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHandGrabAction, bool, Pressed, bool, RightGrab);
 
UCLASS(Blueprintable)
class PIXOCORE_API APixoVRCharacter : public AVRCharacter
{
    GENERATED_BODY()
 
public:
    APixoVRCharacter();
 
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
    virtual void PossessedBy(AController* NewController) override;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "PixoVR")
    float DefaultPlayerHeight;
    
    /********************************* Teleport *********************************/ 
    UFUNCTION(BlueprintCallable) void HandleTeleportLeftPressed();
    UFUNCTION(BlueprintCallable) void HandleTeleportLeftReleased();
    UFUNCTION(BlueprintCallable) void HandleTeleportRightPressed();
    UFUNCTION(BlueprintCallable) void HandleTeleportRightReleased();
    
    UFUNCTION(Server, Unreliable, WithValidation)
    void HandleTeleportLeftUp(float Value);
    
    UFUNCTION(Server, Unreliable, WithValidation)
    void HandleTeleportLeftRight(float Value);
 
    UFUNCTION(Server, Unreliable, WithValidation)
    void HandleTeleportRightUp(float Value);
    
    UFUNCTION(Server, Unreliable, WithValidation)
    void HandleTeleportRightRight(float Value);
 
    virtual bool CanTeleport() const;
 
    UFUNCTION()
    void ExecuteTeleportation(EControllerHand Hand);
 
    UFUNCTION(BlueprintCallable, Category = "PixoVR")
    void ActivateTeleporter(EControllerHand Hand, bool InActivate);
 
    UFUNCTION(BlueprintCallable, Server, Reliable, WithValidation, Category = "PixoVR")
    void NotifyActivateTeleporter(EControllerHand Hand, bool InActivate);
 
    UFUNCTION(BlueprintCallable, NetMulticast, Reliable, Category = "PixoVR")
    void MulticastActivateTeleporter(EControllerHand Hand, bool InActivate);
 
    UFUNCTION()
    void SpawnTeleporter(EControllerHand Hand, bool InActivate);
 
    UPROPERTY(BlueprintReadWrite, Category = "PixoVR")
    bool bLaserBeamActive;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName LeftTeleporterSocket;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName RightTeleporterSocket;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR")
    APixoVRTeleporter* TeleportControllerLeft;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR")
    APixoVRTeleporter* TeleportControllerRight;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    TSubclassOf<APixoVRTeleporter> TeleportControllerClass;
 
    UPROPERTY(EditAnywhere, Replicated, BlueprintReadWrite, Category = "PixoVR")
    bool bTeleporterEnabled = true;
 
    FOnTeleportationActivated& OnTeleportationActivated() { return OnTeleportationActivatedEvent; };
 
    /****************************** Laser ****************************/ 
    UFUNCTION(BlueprintCallable) void HandleLaserBeamLeftPressed();
    UFUNCTION(BlueprintCallable) void HandleLaserBeamRightPressed();
 
    UFUNCTION (BlueprintCallable, BlueprintPure)
    void IsLaserActivated (bool& IsActivated, EControllerHand& Hand);
 
    UFUNCTION(Server, Reliable, WithValidation)
    void IsOverWidgetUse(EControllerHand Hand, bool InPressed);
 
    UFUNCTION(Client, Reliable)
    void PerformIsOverWidgetUse(EControllerHand Hand, bool InPressed);
 
    UFUNCTION(Server, Reliable)
    void HandleLaserSelectEvent(EControllerHand Hand, bool Pressed);
    UFUNCTION(NetMulticast, Reliable)
    void MultiHandleLaserSelectEvent(EControllerHand Hand, bool Pressed);
    UFUNCTION()
    void HandleLaserSelect(EControllerHand Hand, bool Pressed);
    
    UFUNCTION()
    void SpawnLaserBeam(EControllerHand Hand, bool InActivate);
 
    //Laser Beam Select
    
    void HandleLaserSelectLeft();
    void HandleLaserReleaseLeft();
    void HandleLaserSelectRight();
    void HandleLaserReleaseRight();
 
    UFUNCTION(BlueprintCallable, Server, Reliable, WithValidation, Category = "PixoVR")
    void ActivateLaserBeam(EControllerHand Hand, bool InActivate);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCallable, Category ="PixoVR")
    void HandleHandAnimationLaser(EControllerHand Hand);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName LeftLaserBeamSocket;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName RightLaserBeamSocket;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR")
    APixoVRLaser* LaserControllerLeft;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR")
    APixoVRLaser* LaserControllerRight;
    
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "PixoVR")
    bool bLeftLaserBeamIsActiveOnStart;
    
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "PixoVR")
    bool bRightLaserBeamIsActiveOnStart;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    TSubclassOf<APixoVRLaser> LaserControllerClass;
 
    UPROPERTY(BlueprintReadOnly, Replicated)
    bool bActivateLeftLaser;
    
    UPROPERTY(BlueprintReadOnly, Replicated)
    bool bActivateRightLaser;
 
    /********************************* WristMenu *********************************/
    UFUNCTION(BlueprintCallable)
    void HandleActivateWristMenuPressed();
    
    UFUNCTION(BlueprintCallable)
    void HandleSelectWristMenuItemPressed();
 
    UFUNCTION(BlueprintCallable)
    void SelectWristMenu(EControllerHand Hand);
    
    UFUNCTION(BlueprintCallable)
    void HandleActivateWristMenuPressedLeft();
    
    UFUNCTION(BlueprintCallable)
    void HandleActivateWristMenuPressedRight();
 
    UFUNCTION(Server, Reliable, WithValidation)
    void SpawnWristMenu();
 
    UFUNCTION(Server, Reliable, WithValidation)
    void SpawnProgressBar();
    
    UFUNCTION(BlueprintCallable, Server, Reliable, WithValidation, Category = "PixoVR")
    void ActivateWristMenu(EControllerHand Hand);
 
    UFUNCTION(BlueprintCallable, Server, Reliable, WithValidation, Category = "PixoVR")
    void ActivateProgressBar(EControllerHand Hand,  bool InActivate);
 
    virtual void HandleSelectWristMenuItemPressedLeft();
    virtual void HandleSelectWristMenuItemPressedRight();
    
    virtual void HandleWristMenuItem1Pressed();
    virtual void HandleWristMenuItem2Pressed();
    virtual void HandleWristMenuItem3Pressed();
    virtual void HandleWristMenuItem4Pressed();
    virtual void HandleWristMenuItem5Pressed();
    virtual void HandleWristMenuItem6Pressed();
    virtual void HandleWristMenuItem7Pressed();
    virtual void HandleWristMenuItem8Pressed();
 
    virtual void HandleWristMenuDoubleTap(FKey InputKey);
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "PixoVR")
    USceneComponent* WristMenuLoc;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    TSubclassOf<APixoVRWristMenu> WristMenuClass;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    TSubclassOf<APixoVRCircleProgress> ProgressBarClass;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName WristMenuSocket;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR", meta = (AllowPrivateAccess = "true"))
    APixoVRWristMenu* WristMenu;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "PixoVR", meta = (AllowPrivateAccess = "true"))
    UPixoVRLongHoldComponent* LongHoldComponent;
 
    UPROPERTY(BlueprintReadOnly, Replicated, Category = "PixoVR", meta = (AllowPrivateAccess = "true"))
    APixoVRCircleProgress* ProgressBar;
 
    FVector MirroredWristMenuScale;
    
    UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Replicated, Category= "PixoVR")
    EControllerHand CurrentWristMenuHand;
 
    UPROPERTY(BlueprintAssignable)
    FOnWristMenuActivated OnWristMenuActivated;
    
    /****************************************************************/
    
    virtual void TurnVRLeft();
    virtual void TurnVRRight();
 
    UFUNCTION(NetMulticast, Reliable)
    void ActivateFPSMode(bool Enable);
    
    void MoveForward(float Value);
    void MoveRight(float Value);
    void TurnAtRate(float Rate);
    void LookUpAtRate(float Rate);
 
    /****************************** Hands ****************************/
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Hands")
    TSubclassOf<APixoVRHand> VRHandClass;
    
    UPROPERTY(BlueprintReadOnly, Category = "Hands")
    APixoVRHand* VRHandLeft;
    UPROPERTY(BlueprintReadOnly, Category = "Hands")
    APixoVRHand* VRHandRight;
    
    UFUNCTION(BlueprintCallable, Category = "Hands")
    virtual void GrabRightPressed();
    UFUNCTION(BlueprintCallable, Category = "Hands")
    virtual void GrabLeftPressed();
    UFUNCTION(BlueprintCallable, Category = "Hands")
    virtual void GrabRightReleased();
    UFUNCTION(BlueprintCallable, Category = "Hands")
    virtual void GrabLeftReleased();
 
    UFUNCTION(BlueprintCallable, Category = "Hands")
    AActor* SpawnActorInHand(TSubclassOf<AActor> ActorClass, bool RightHand);
 
    UFUNCTION(BlueprintCallable, Category = "Hands")
    void ResetHandHoldingObject();
    UFUNCTION(BlueprintCallable, Category = "Hands")
    void ResetHand(bool RightHand);
    bool HoldToolRight;
    bool HoldToolLeft;
 
    UFUNCTION(BlueprintCallable)
    void ShowTool(EControllerHand Hand, AActor* Tool);
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PixoVR")
    FName ToolSocket;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Fade")
    UStaticMeshComponent* FadeSphere;
 
    UPROPERTY(BlueprintAssignable, Category = "Hands")
    FOnHandGrabAction OnHandGrabAction;
 
    /****************************** Hints ****************************/
    UPROPERTY(BlueprintReadOnly)
    UHintManager* HintManager;
 
    UFUNCTION(BlueprintCallable, Category = "Hint")
    void ActivateHint();
    UFUNCTION(BlueprintCallable, Category = "Hint")
    void DeactivateHint();
    
    float BaseTurnRate;
    float BaseLookUpRate;
    float DeflectionAngle = 30.0f; 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="PixoVR", Meta=(Tooltip="If checked, Laser, Teleporter and Wrist Menu input handling will be disabled."))
    bool bDisableToolsInputBindings;
    
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category="PixoVR")
    UDataTable* InputsTable;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "PixoVR", meta = (AllowPrivateAccess = "true"))
    UStaticMeshComponent* Head;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "PixoVR", meta = (AllowPrivateAccess = "true"))
    UStaticMeshComponent* Body;
 
    FVector2D LastTeleportLeftDirectionVector;
    FVector2D LastTeleportRightDirectionVector;
    
    FKey LastPressedKey;
    
private:
    UFUNCTION()
    void PlayerDestroyed(AActor* Act);
    
    UPROPERTY()
    UPixoVRInputAdapter* InputAdapter;
 
    bool bFPSMode;
 
    FOnTeleportationActivated OnTeleportationActivatedEvent;
 
    UPROPERTY(Replicated)
    bool bIsOverWidgetUse = false;
};