LocalPlayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//=============================================================================
// LocalPlayer
//=============================================================================
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Input/Reply.h"
#include "Online/CoreOnline.h"
#include "SceneTypes.h"
#include "Engine/Player.h"
#include "GameFramework/OnlineReplStructs.h"
#include "GameFramework/PlayerController.h"
 
#include "Subsystems/LocalPlayerSubsystem.h"
#include "Subsystems/SubsystemCollection.h"
 
#include "LocalPlayer.generated.h"
 
 
#define INVALID_CONTROLLERID (-1)
 
class AActor;
class FSceneView;
class FSlateUser;
class FViewport;
class UGameInstance;
class UGameViewportClient;
class ULocalPlayer;
struct FMinimalViewInfo;
struct FSceneViewProjectionData;
 
struct FLocalPlayerContext
{
    ENGINE_API FLocalPlayerContext();
    ENGINE_API FLocalPlayerContext(const class ULocalPlayer* InLocalPlayer, UWorld* InWorld = nullptr);
    ENGINE_API FLocalPlayerContext(const class APlayerController* InPlayerController);
 
    ENGINE_API bool IsValid() const;
 
    ENGINE_API bool IsInitialized() const;
 
    ENGINE_API bool IsFromLocalPlayer(const AActor* ActorToTest) const;
 
    ENGINE_API UWorld* GetWorld() const;
 
    ENGINE_API UGameInstance* GetGameInstance() const;
 
    ENGINE_API class ULocalPlayer* GetLocalPlayer() const;
 
    ENGINE_API class APlayerController* GetPlayerController() const;
 
    template<class T>
    inline T* GetPlayerController(bool bCastChecked = false) const
    {
        if (bCastChecked)
        { 
            return CastChecked<T>(GetPlayerController(), ECastCheckedType::NullAllowed);
        }
        else
        {
            return Cast<T>(GetPlayerController());
        }
    }
 
    ENGINE_API class AGameStateBase* GetGameState() const;
 
    template<class T>
    inline T* GetGameState(bool bCastChecked = false) const
    {
        if (bCastChecked)
        {
            return CastChecked<T>(GetGameState(), ECastCheckedType::NullAllowed);
        }
        else
        {
            return Cast<T>(GetGameState());
        }
    }
 
    ENGINE_API class APlayerState* GetPlayerState() const;
 
    template<class T>
    inline T* GetPlayerState(bool bCastChecked = false) const
    {
        if (bCastChecked)
        {
            return CastChecked<T>(GetPlayerState(), ECastCheckedType::NullAllowed);
        }
        else
        {
            return Cast<T>(GetPlayerState());
        }
    }
 
    ENGINE_API class AHUD* GetHUD() const;
 
    template<class T>
    inline T* GetHUD(bool bCastChecked = false) const
    {
        if (bCastChecked)
        {
            return CastChecked<T>(GetHUD(), ECastCheckedType::NullAllowed);
        }
        else
        {
            return Cast<T>(GetHUD());
        }
    }
 
    ENGINE_API class APawn* GetPawn() const;
 
    template<class T>
    inline T* GetPawn(bool bCastChecked = false) const
    {
        if (bCastChecked)
        {
            return CastChecked<T>(GetPawn(), ECastCheckedType::NullAllowed);
        }
        else
        {
            return Cast<T>(GetPawn());
        }
    }
 
private:    
 
    /* Set the local player. */
    ENGINE_API void SetLocalPlayer( const class ULocalPlayer* InLocalPlayer );
 
    /* Set the local player via a player controller. */
    ENGINE_API void SetPlayerController( const class APlayerController* InPlayerController );
 
    TWeakObjectPtr<class ULocalPlayer>      LocalPlayer;
 
    TWeakObjectPtr<UWorld>                  World;
};
 
UCLASS(Within=Engine, config=Engine, transient, MinimalAPI)
class ULocalPlayer : public UPlayer
{
    GENERATED_UCLASS_BODY()
 
public:
 
    ENGINE_API ULocalPlayer(FVTableHelper& Helper);
 
    FUniqueNetIdRepl CachedUniqueNetId;
 
    UPROPERTY()
    TObjectPtr<class UGameViewportClient> ViewportClient;
 
    FVector2D Origin;
 
    FVector2D Size;
 
    FVector LastViewLocation;
 
    UPROPERTY(config)
    TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
 
    UPROPERTY()
    TSubclassOf<class APlayerController> PendingLevelPlayerControllerClass;
 
    UPROPERTY(VisibleAnywhere, transient, Category=LocalPlayer)
    uint32 bSentSplitJoin:1;
 
    DECLARE_EVENT_TwoParams(ULocalPlayer, FOnControllerIdChanged, int32 /*NewId*/, int32 /*OldId*/);
    FOnControllerIdChanged& OnControllerIdChanged() const { return OnControllerIdChangedEvent; }
 
    DECLARE_EVENT_TwoParams(ULocalPlayer, FOnPlatformUserIdChanged, FPlatformUserId /*NewId*/, FPlatformUserId /*OldId*/);
    FOnPlatformUserIdChanged& OnPlatformUserIdChanged() { return OnPlatformUserIdChangedEvent; }
 
    DECLARE_EVENT_OneParam(ULocalPlayer, FOnPlayerControllerChanged, APlayerController* /*NewPC*/);
    FOnPlayerControllerChanged& OnPlayerControllerChanged() { return OnPlayerControllerChangedEvent; }
 
    bool bEmulateSplitscreen = false;
    
    ENGINE_API void SetConnectionIdentifier(const int32 Id);
 
    ENGINE_API int32 GetConnectionIdentifier() const;
 
private:
    TArray<FSceneViewStateReference> ViewStates;
 
    UPROPERTY()
    int32 ControllerId = INVALID_CONTROLLERID;
 
    mutable FOnControllerIdChanged OnControllerIdChangedEvent;
 
    int32 ConnectionIdentifier = 0;
 
    FPlatformUserId PlatformUserId;
 
    FOnPlatformUserIdChanged OnPlatformUserIdChangedEvent;
 
    FOnPlayerControllerChanged OnPlayerControllerChangedEvent;
 
    FObjectSubsystemCollection<ULocalPlayerSubsystem> SubsystemCollection;
 
public:
    // UObject interface
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    // End of UObject interface
 
    // Begin UPlayer interface
    ENGINE_API virtual void ReceivedPlayerController(APlayerController* NewController) override;
    // End UPlayer interface
    
    // FExec interface
public:
#if UE_ALLOW_EXEC_COMMANDS
    ENGINE_API virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd,FOutputDevice& Ar) override;
#endif
protected:
    ENGINE_API virtual bool Exec_Editor(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
    // End of FExec interface
 
public:
    ENGINE_API bool HandleDNCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleExitCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListMoveBodyCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListAwakeBodiesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListSimBodiesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleMoveComponentTimesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListSkelMeshesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListPawnComponentsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleExecCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleDrawEventsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleStreamingVolumesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    
protected:
    ENGINE_API virtual void GetViewPoint(FMinimalViewInfo& OutViewInfo) const;
 
    ENGINE_API void ExecMacro( const TCHAR* Filename, FOutputDevice& Ar );
 
    FReply SlateOperations;
 
public:
 
    FReply& GetSlateOperations() { return SlateOperations; }
    const FReply& GetSlateOperations() const { return SlateOperations; }
 
    ENGINE_API virtual TSharedPtr<FSlateUser> GetSlateUser();
    ENGINE_API virtual TSharedPtr<const FSlateUser> GetSlateUser() const;
 
    ENGINE_API virtual UWorld* GetWorld() const override;
 
    ENGINE_API UGameInstance* GetGameInstance() const;
 
    ENGINE_API int32 GetIndexInGameInstance() const;
 
    ULocalPlayerSubsystem* GetSubsystemBase(TSubclassOf<ULocalPlayerSubsystem> SubsystemClass) const
    {
        return SubsystemCollection.GetSubsystem<ULocalPlayerSubsystem>(SubsystemClass);
    }
 
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem() const
    {
        return SubsystemCollection.GetSubsystem<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    static inline TSubsystemClass* GetSubsystem(const ULocalPlayer* LocalPlayer)
    {
        if (LocalPlayer)
        {
            return LocalPlayer->GetSubsystem<TSubsystemClass>();
        }
        return nullptr;
    }
 
    template <typename TSubsystemClass>
    static FORCEINLINE TSubsystemClass* GetSubsystemFromController(const APlayerController* PC)
    {
        if (PC)
        {
            const ULocalPlayer* LocalPlayer = PC->GetLocalPlayer();
            return LocalPlayer ? LocalPlayer->GetSubsystem<TSubsystemClass>() : nullptr;
        }
        return nullptr;
    }
    
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy() const
    {
        return SubsystemCollection.GetSubsystemArrayCopy<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    void ForEachSubsystem(TFunctionRef<void(TSubsystemClass*)> Operation) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, ULocalPlayerSubsystem>::IsDerived, "TSubsystemClass must be derived from ULocalPlayerSubsystem");
        return SubsystemCollection.ForEachSubsystem([Operation=MoveTemp(Operation)](ULocalPlayerSubsystem* Subsystem){
            Operation(CastChecked<TSubsystemClass>(Subsystem));
        }, TSubsystemClass::StaticClass());
    }
 
 
    ENGINE_API virtual bool CalcSceneViewInitOptions(
        struct FSceneViewInitOptions& OutInitOptions,
        FViewport* Viewport,
        class FViewElementDrawer* ViewDrawer = NULL,
        int32 StereoViewIndex = INDEX_NONE);
 
    ENGINE_API virtual FSceneView* CalcSceneView(class FSceneViewFamily* ViewFamily,
        FVector& OutViewLocation,
        FRotator& OutViewRotation,
        FViewport* Viewport,
        class FViewElementDrawer* ViewDrawer = NULL,
        int32 StereoViewIndex = INDEX_NONE);
 
    ENGINE_API virtual void PlayerAdded(class UGameViewportClient* InViewportClient, int32 InControllerID);
 
    ENGINE_API virtual void PlayerAdded(class UGameViewportClient* InViewportClient, FPlatformUserId InUserId);
 
    ENGINE_API virtual void InitOnlineSession();
 
    ENGINE_API virtual void PlayerRemoved();
 
    ENGINE_API virtual bool SpawnPlayActor(const FString& URL,FString& OutError, UWorld* InWorld);
 
    DECLARE_DELEGATE(FOnPreBeginHandshakeCompleteDelegate);
 
    virtual void PreBeginHandshake(const FOnPreBeginHandshakeCompleteDelegate& OnComplete) { OnComplete.ExecuteIfBound(); }
 
    ENGINE_API virtual void SendSplitJoin(TArray<FString>& Options);
 
    ENGINE_API virtual void SendSplitJoin(TArray<FString>& Options, UNetDriver* NetDriver, UE::Net::EJoinFlags Flags);
    
    ENGINE_API virtual void SetControllerId(int32 NewControllerId);
 
    int32 GetControllerId() const { return ControllerId; }
 
    ENGINE_API virtual void SetPlatformUserId(FPlatformUserId InPlatformUserId);
 
    FPlatformUserId GetPlatformUserId() const { return PlatformUserId; }
 
    ENGINE_API virtual int32 GetPlatformUserIndex() const;
 
    ENGINE_API virtual int32 GetLocalPlayerIndex() const;
 
    ENGINE_API virtual FString GetNickname() const;
 
    virtual FString GetGameLoginOptions() const { return TEXT(""); }
 
    // This should be deprecated when engine code has been changed to expect FPlatformUserId
    // UE_DEPRECATED(5.x, "Use GetUniqueNetIdForPlatformUser instead")
    ENGINE_API FUniqueNetIdRepl GetUniqueNetIdFromCachedControllerId() const;
 
    ENGINE_API virtual FUniqueNetIdRepl GetUniqueNetIdForPlatformUser() const;
 
    ENGINE_API FUniqueNetIdRepl GetCachedUniqueNetId() const;
 
    ENGINE_API void SetCachedUniqueNetId(const FUniqueNetIdRepl& NewUniqueNetId);
 
    ENGINE_API virtual FUniqueNetIdRepl GetPreferredUniqueNetId() const;
 
    ENGINE_API bool GetPixelBoundingBox(const FBox& ActorBox, FVector2D& OutLowerLeft, FVector2D& OutUpperRight, const FVector2f* OptionalAllotedSize = nullptr);
    static ENGINE_API bool GetPixelBoundingBox(const FSceneViewProjectionData& ProjectionData, const FBox& ActorBox, FVector2D& OutLowerLeft, FVector2D& OutUpperRight, const FVector2f* OptionalAllotedSize = nullptr);
 
    ENGINE_API bool GetPixelPoint(const FVector& InPoint, FVector2D& OutPoint, const FVector2f* OptionalAllotedSize = nullptr);
    static ENGINE_API bool GetPixelPoint(const FSceneViewProjectionData& ProjectionData, const FVector& InPoint, FVector2D& OutPoint, const FVector2f* OptionalAllotedSize = nullptr);
 
    ENGINE_API virtual bool GetProjectionData(FViewport* Viewport, FSceneViewProjectionData& ProjectionData, int32 StereoViewIndex = INDEX_NONE) const;
 
    ENGINE_API bool IsPrimaryPlayer() const;
     
    ENGINE_API virtual void CleanupViewState(FStringView MidParentRootPath = {});
 
    friend class FLockedViewState;
};