PlayerController_8h_source.html

// Copyright Epic Games, Inc. All Rights Reserved.


#pragma once


#include "SlateFwd.h"

#include "UObject/ObjectMacros.h"

#include "Containers/SortedMap.h"

#include "Containers/StaticArray.h"

#include "Misc/Guid.h"

#include "InputCoreTypes.h"

#include "Templates/SubclassOf.h"

#include "Engine/NetSerialization.h"

#include "Engine/EngineTypes.h"

#include "Engine/EngineBaseTypes.h"

#include "Engine/LatentActionManager.h"

#include "SceneTypes.h"

#include "GameFramework/Controller.h"

#include "UObject/TextProperty.h"

#include "GameFramework/PlayerMuteList.h"

#include "GameFramework/OnlineReplStructs.h"

#include "Camera/PlayerCameraManager.h"

#include "GameFramework/ForceFeedbackParameters.h"

#include "GameFramework/UpdateLevelVisibilityLevelInfo.h"

#include "GenericPlatform/ICursor.h"

#include "GenericPlatform/IInputInterface.h"

#include "Physics/AsyncPhysicsData.h"

#include "WorldPartition/WorldPartitionStreamingSource.h"

#include "EngineDefines.h"      // For UE_ENABLE_DEBUG_DRAWING

#include "InputKeyEventArgs.h"


#include "PlayerController.generated.h"


class ACameraActor;

class AHUD;

class APawn;

class ASpectatorPawn;

class FDebugDisplayInfo;

class SWidget;

class UActorChannel;

class UCheatManager;

class UGameViewportClient;

class UInputComponent;

class ULocalMessage;

class UNetConnection;

class UPlayer;

class UPlayerInput;

class UPrimitiveComponent;

namespace EControllerAnalogStick { enum Type : int; }

struct FActiveForceFeedbackEffect;

struct FActiveHapticFeedbackEffect;

struct FCollisionQueryParams;

struct FForceFeedbackEffectHistoryEntry;

struct FInputKeyParams;

struct FPlatformUserId;

class UAsyncPhysicsInputComponent;


DECLARE_DELEGATE_RetVal(bool, FCanUnpause);


DECLARE_DELEGATE_ThreeParams(FGetAudioListenerPos, FVector& /*Location*/, FVector& /*ProjFront*/, FVector& /*ProjRight*/);


ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogPlayerController, Log, All);

DECLARE_STATS_GROUP(TEXT("PlayerController"), STATGROUP_PlayerController, STATCAT_Advanced);


UENUM()


namespace EDynamicForceFeedbackAction

{


    enum Type : int

    {

        Start,

        Update,

        Stop,

    };


}


typedef uint64 FDynamicForceFeedbackHandle;


struct FDynamicForceFeedbackDetails

{

    uint32 bAffectsLeftLarge:1;

    uint32 bAffectsLeftSmall:1;

    uint32 bAffectsRightLarge:1;

    uint32 bAffectsRightSmall:1;


    float Intensity;


    FDynamicForceFeedbackDetails()

        : bAffectsLeftLarge(true)

        , bAffectsLeftSmall(true)

        , bAffectsRightLarge(true)

        , bAffectsRightSmall(true)

        , Intensity(0.f)

    {}


    void Update(FForceFeedbackValues& Values) const;

};


struct FInputModeDataBase

{

protected:

    virtual ~FInputModeDataBase() { }


    virtual void ApplyInputMode(class FReply& SlateOperations, class UGameViewportClient& GameViewportClient) const = 0;


    virtual bool ShouldFlushInputOnViewportFocus() const { return true; };


    ENGINE_API void SetFocusAndLocking(FReply& SlateOperations, TSharedPtr<class SWidget> InWidgetToFocus, bool bLockMouseToViewport, TSharedRef<class SViewport> InViewportWidget) const;


    friend class APlayerController;


public:


#if UE_ENABLE_DEBUG_DRAWING

    ENGINE_API virtual const FString& GetDebugDisplayName() const;

#endif  // UE_ENABLE_DEBUG_DRAWING

};


struct FInputModeUIOnly : public FInputModeDataBase

{

    ENGINE_API FInputModeUIOnly();


    ENGINE_API virtual ~FInputModeUIOnly();


    ENGINE_API FInputModeUIOnly& SetWidgetToFocus(TSharedPtr<SWidget> InWidgetToFocus);


    ENGINE_API FInputModeUIOnly& SetLockMouseToViewportBehavior(EMouseLockMode InMouseLockMode);


#if UE_ENABLE_DEBUG_DRAWING

    ENGINE_API virtual const FString& GetDebugDisplayName() const override;

#endif  // UE_ENABLE_DEBUG_DRAWING


protected:

    TSharedPtr<SWidget> WidgetToFocus;

    EMouseLockMode MouseLockMode;


    ENGINE_API virtual void ApplyInputMode(FReply& SlateOperations, class UGameViewportClient& GameViewportClient) const override;

};


USTRUCT()


struct FUpdateLevelStreamingLevelStatus

{

    GENERATED_BODY();


    UPROPERTY()

    FName PackageName;


    UPROPERTY()

    int32 LODIndex = 0;


    UPROPERTY()

    bool bNewShouldBeLoaded = false;


    UPROPERTY()

    bool bNewShouldBeVisible = false;


    UPROPERTY()

    bool bNewShouldBlockOnLoad = false;


    UPROPERTY()

    bool bNewShouldBlockOnUnload = false;

};


struct FInputModeGameAndUI : public FInputModeDataBase

{

    ENGINE_API FInputModeGameAndUI();


    ENGINE_API virtual ~FInputModeGameAndUI();


    FInputModeGameAndUI& SetWidgetToFocus(TSharedPtr<SWidget> InWidgetToFocus) { WidgetToFocus = InWidgetToFocus; return *this; }


    FInputModeGameAndUI& SetLockMouseToViewportBehavior(EMouseLockMode InMouseLockMode) { MouseLockMode = InMouseLockMode; return *this; }


    FInputModeGameAndUI& SetHideCursorDuringCapture(bool InHideCursorDuringCapture) { bHideCursorDuringCapture = InHideCursorDuringCapture; return *this; }


    virtual bool ShouldFlushInputOnViewportFocus() const override { return false; }


#if UE_ENABLE_DEBUG_DRAWING

    ENGINE_API virtual const FString& GetDebugDisplayName() const override;

#endif  // UE_ENABLE_DEBUG_DRAWING


protected:


    TSharedPtr<SWidget> WidgetToFocus;

    EMouseLockMode MouseLockMode;

    bool bHideCursorDuringCapture;


    ENGINE_API virtual void ApplyInputMode(FReply& SlateOperations, class UGameViewportClient& GameViewportClient) const override;

};


struct FInputModeGameOnly : public FInputModeDataBase

{

    ENGINE_API FInputModeGameOnly();


    ENGINE_API virtual ~FInputModeGameOnly();


    FInputModeGameOnly& SetConsumeCaptureMouseDown(bool InConsumeCaptureMouseDown) { bConsumeCaptureMouseDown = InConsumeCaptureMouseDown; return *this; }


#if UE_ENABLE_DEBUG_DRAWING

    ENGINE_API virtual const FString& GetDebugDisplayName() const override;

#endif  // UE_ENABLE_DEBUG_DRAWING


protected:

    bool bConsumeCaptureMouseDown;


    ENGINE_API virtual void ApplyInputMode(FReply& SlateOperations, class UGameViewportClient& GameViewportClient) const override;

};


USTRUCT()


struct FAsyncPhysicsTimestamp

{

    GENERATED_BODY()


    bool IsValid() const

    {

        return ServerFrame != INDEX_NONE && LocalFrame != INDEX_NONE;

    }


    UPROPERTY()

    int32 ServerFrame = INDEX_NONE;


    UPROPERTY()

    int32 LocalFrame = INDEX_NONE;


};


UCLASS(config=Game, BlueprintType, Blueprintable, meta=(ShortTooltip="A Player Controller is an actor responsible for controlling a Pawn used by the player."), MinimalAPI)


class APlayerController : public AController, public IWorldPartitionStreamingSourceProvider

{

    GENERATED_BODY()


public:

    ENGINE_API APlayerController(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());


    UPROPERTY()

    TObjectPtr<UPlayer> Player;


    UPROPERTY()

    TObjectPtr<APawn> AcknowledgedPawn;


    UPROPERTY()

    TObjectPtr<AHUD> MyHUD;


    // ******************************************************************************

    // Camera/view related variables


    UPROPERTY(BlueprintReadOnly, Category=PlayerController)

    TObjectPtr<APlayerCameraManager> PlayerCameraManager;


    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlayerController)

    TSubclassOf<APlayerCameraManager> PlayerCameraManagerClass;


    UPROPERTY(EditAnywhere, Category=PlayerController)

    bool bAutoManageActiveCameraTarget;


    UPROPERTY(replicated)

    FRotator TargetViewRotation;


    ENGINE_API void SetTargetViewRotation(const FRotator& InRotation);


    FRotator BlendedTargetViewRotation;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerController)

    float SmoothTargetViewRotationSpeed;


    float LocalPlayerCachedLODDistanceFactor;


    UPROPERTY()

    TArray<TObjectPtr<class AActor>> HiddenActors;


    UPROPERTY()

    TArray< TWeakObjectPtr<UPrimitiveComponent> > HiddenPrimitiveComponents;


    bool bRenderPrimitiveComponents;


    UPROPERTY()

    float LastSpectatorStateSynchTime;


    UPROPERTY(Transient)

    FVector LastSpectatorSyncLocation;


    UPROPERTY(Transient)

    FRotator LastSpectatorSyncRotation;


    UPROPERTY()

    int32 ClientCap;


    UPROPERTY(Transient, BlueprintReadOnly, Category="Cheat Manager")

    TObjectPtr<UCheatManager> CheatManager;


    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Cheat Manager")

    TSubclassOf<UCheatManager> CheatClass;


    UPROPERTY(Transient)

    TObjectPtr<UPlayerInput> PlayerInput;


    UPROPERTY(Transient)

    TArray<FActiveForceFeedbackEffect> ActiveForceFeedbackEffects;


#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)

    TArray<FForceFeedbackEffectHistoryEntry> ForceFeedbackEffectHistoryEntries;

#endif


protected:

    ENGINE_API virtual void OnReplicationStartedForIris(const FOnReplicationStartedParams&) override;


private:


    struct FDynamicForceFeedbackAction

    {

        float TotalTime;

        float TimeElapsed;

        FDynamicForceFeedbackDetails ForceFeedbackDetails;

        FDynamicForceFeedbackHandle Handle;

        static FDynamicForceFeedbackHandle HandleAllocator;


        bool Update(const float DeltaTime, FForceFeedbackValues& Values);

    };


    TSortedMap<FDynamicForceFeedbackHandle, FDynamicForceFeedbackAction> DynamicForceFeedbacks;


    TSortedMap<int32, FDynamicForceFeedbackDetails*> LatentDynamicForceFeedbacks;


    friend class FLatentDynamicForceFeedbackAction;


public:


    TSharedPtr<struct FActiveHapticFeedbackEffect> ActiveHapticEffect_Left;

    TSharedPtr<struct FActiveHapticFeedbackEffect> ActiveHapticEffect_Right;

    TSharedPtr<struct FActiveHapticFeedbackEffect> ActiveHapticEffect_Gun;

    TSharedPtr<struct FActiveHapticFeedbackEffect> ActiveHapticEffect_HMD;


    FForceFeedbackValues ForceFeedbackValues;


    TArray<FName> PendingMapChangeLevelNames;


    uint32 bShortConnectTimeOut:1;


    uint32 bCinematicMode:1;


    uint32 bHidePawnInCinematicMode:1;


    uint32 bIsUsingStreamingVolumes:1;


    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category=PlayerController)

    uint32 bPlayerIsWaiting:1;


    UFUNCTION(server, reliable, WithValidation, Category=PlayerController)

    ENGINE_API void ServerSetSpectatorWaiting(bool bWaiting);


    UFUNCTION(client, reliable, Category=PlayerController)

    ENGINE_API void ClientSetSpectatorWaiting(bool bWaiting);


    UPROPERTY(DuplicateTransient)

    uint8 NetPlayerIndex;


    FPlayerMuteList MuteList;


    UPROPERTY(DuplicateTransient)

    TObjectPtr<UNetConnection> PendingSwapConnection;


    UPROPERTY(DuplicateTransient)

    TObjectPtr<UNetConnection> NetConnection;


    FRotator RotationInput;


    UPROPERTY(config, meta = (DeprecatedProperty, DeprecationMessage = "Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior"))

    float InputYawScale_DEPRECATED = 1.0f;


    UPROPERTY(config, meta = (DeprecatedProperty, DeprecationMessage = "Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior"))

    float InputPitchScale_DEPRECATED = 1.0f;


    UPROPERTY(config, meta = (DeprecatedProperty, DeprecationMessage = "Use the Enhanced Input plugin Scalar Modifier instead. See UInputSettings::bEnableLegacyInputScales to enable legacy behavior"))

    float InputRollScale_DEPRECATED = 1.0f;


    UE_DEPRECATED(5.0, "GetDeprecatedInputYawScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API float GetDeprecatedInputYawScale() const;


    UE_DEPRECATED(5.0, "GetDeprecatedInputPitchScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API float GetDeprecatedInputPitchScale() const;


    UE_DEPRECATED(5.0, "GetDeprecatedInputRollScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.)")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API float GetDeprecatedInputRollScale() const;


    UE_DEPRECATED(5.0, "SetDeprecatedInputYawScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API void SetDeprecatedInputYawScale(float NewValue);


    UE_DEPRECATED(5.0, "SetDeprecatedInputPitchScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API void SetDeprecatedInputPitchScale(float NewValue);


    UE_DEPRECATED(5.0, "SetDeprecatedInputRollScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.)")

    UFUNCTION(BlueprintCallable, Category = PlayerController)

    ENGINE_API void SetDeprecatedInputRollScale(float NewValue);


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Setter=SetShowMouseCursor, Category=MouseInterface)

    uint32 bShowMouseCursor:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface)

    uint32 bEnableClickEvents:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface)

    uint32 bEnableTouchEvents:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface)

    uint32 bEnableMouseOverEvents:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface)

    uint32 bEnableTouchOverEvents:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Game|Feedback")

    uint32 bForceFeedbackEnabled:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetMotionControlsEnabled, Category="Input")

    uint32 bEnableMotionControls:1;


    UFUNCTION(BlueprintSetter)

    ENGINE_API void SetMotionControlsEnabled(bool bEnabled);


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition)

    uint32 bEnableStreamingSource:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition, meta=(EditCondition="bEnableStreamingSource"))

    uint32 bStreamingSourceShouldActivate:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition, meta=(EditCondition="bEnableStreamingSource"))

    uint32 bStreamingSourceShouldBlockOnSlowStreaming:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition, meta=(EditCondition="bEnableStreamingSource"))

    EStreamingSourcePriority StreamingSourcePriority;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition, meta = (EditCondition = "bEnableStreamingSource"))

    FColor StreamingSourceDebugColor;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPartition, meta = (EditCondition = "bEnableStreamingSource"))

    TArray<FStreamingSourceShape> StreamingSourceShapes;


    UPROPERTY(config)

    float ForceFeedbackScale;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface, meta=(EditCondition="bEnableClickEvents"))

    TArray<FKey> ClickEventKeys;


    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MouseInterface)

    TEnumAsByte<EMouseCursor::Type> DefaultMouseCursor;


    UPROPERTY(BlueprintReadWrite, Category=MouseInterface)

    TEnumAsByte<EMouseCursor::Type> CurrentMouseCursor;


    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MouseInterface)

    TEnumAsByte<ECollisionChannel> DefaultClickTraceChannel;


    UPROPERTY(BlueprintReadWrite, Category=MouseInterface)

    TEnumAsByte<ECollisionChannel> CurrentClickTraceChannel;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MouseInterface, meta=(DisplayName="Trace Distance"))

    float HitResultTraceDistance;


    UPROPERTY()

    uint16 SeamlessTravelCount;


    UPROPERTY()

    uint16 LastCompletedSeamlessTravelCount;


public:

    UFUNCTION(exec)

    ENGINE_API virtual void EnableCheats();


    ENGINE_API virtual void UnFreeze();


    ENGINE_API virtual float GetMinRespawnDelay();


    UFUNCTION(exec)

    ENGINE_API virtual void FOV(float NewFOV);


    UFUNCTION(exec)

    ENGINE_API virtual void RestartLevel();


    UFUNCTION(exec)

    ENGINE_API virtual void LocalTravel(const FString& URL);


    UFUNCTION(Reliable, Server, WithValidation)

    ENGINE_API void ServerExecRPC(const FString& Msg);


    UFUNCTION(exec)

    ENGINE_API void ServerExec(const FString& Msg);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientReturnToMainMenuWithTextReason(const FText& ReturnReason);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientRepObjRef(UObject* Object);


    ENGINE_API virtual bool SetPause(bool bPause, FCanUnpause CanUnpauseDelegate = FCanUnpause());


    UFUNCTION(exec)

    ENGINE_API virtual void Pause();


    UFUNCTION(exec)

    ENGINE_API virtual void SetName(const FString& S);


    UFUNCTION(exec)

    ENGINE_API virtual void SwitchLevel(const FString& URL);


    ENGINE_API virtual void NotifyLoadedWorld(FName WorldPackageName, bool bFinalDest);


    ENGINE_API virtual void PlayerTick(float DeltaTime);


    ENGINE_API virtual void PreProcessInput(const float DeltaTime, const bool bGamePaused);


    ENGINE_API virtual void PostProcessInput(const float DeltaTime, const bool bGamePaused);


    ENGINE_API virtual void SetCinematicMode( bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning);


    ENGINE_API virtual void ResetIgnoreInputFlags() override;


    ENGINE_API bool GetHitResultAtScreenPosition(const FVector2D ScreenPosition, const ECollisionChannel TraceChannel, const FCollisionQueryParams& CollisionQueryParams, FHitResult& HitResult) const;

    ENGINE_API bool GetHitResultAtScreenPosition(const FVector2D ScreenPosition, const ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;

    ENGINE_API bool GetHitResultAtScreenPosition(const FVector2D ScreenPosition, const ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;

    ENGINE_API bool GetHitResultAtScreenPosition(const FVector2D ScreenPosition, const TArray<TEnumAsByte<EObjectTypeQuery> > & ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(DeprecatedFunction, DeprecationMessage = "Use new GetHitResultUnderCursorByChannel or GetHitResultUnderCursorForObject", TraceChannel=ECC_Visibility, bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderCursor(ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderCursorByChannel(ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderCursorForObjects(const TArray<TEnumAsByte<EObjectTypeQuery> > & ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(DeprecatedFunction, DeprecationMessage = "Use new GetHitResultUnderFingerByChannel or GetHitResultUnderFingerForObject", TraceChannel=ECC_Visibility, bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderFinger(ETouchIndex::Type FingerIndex, ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderFingerByChannel(ETouchIndex::Type FingerIndex, ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(bTraceComplex=true))

    ENGINE_API bool GetHitResultUnderFingerForObjects(ETouchIndex::Type FingerIndex, const  TArray<TEnumAsByte<EObjectTypeQuery> > & ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta = (DisplayName = "Convert Mouse Location To World Space", Keywords = "deproject"))

    ENGINE_API bool DeprojectMousePositionToWorld(FVector& WorldLocation, FVector& WorldDirection) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta = (DisplayName = "Convert Screen Location To World Space", Keywords = "deproject"))

    ENGINE_API bool DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, FVector& WorldLocation, FVector& WorldDirection) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta = (DisplayName = "Convert World Location To Screen Location", Keywords = "project"))

    ENGINE_API bool ProjectWorldLocationToScreen(FVector WorldLocation, FVector2D& ScreenLocation, bool bPlayerViewportRelative = false) const;


    ENGINE_API bool ProjectWorldLocationToScreenWithDistance(FVector WorldLocation, FVector& ScreenLocation, bool bPlayerViewportRelative = false) const;


    ENGINE_API virtual bool PostProcessWorldToScreen(FVector WorldLocation, FVector2D& ScreenLocation, bool bPlayerViewportRelative) const;


    UFUNCTION( BlueprintCallable, Category="Game|Player", meta = (DisplayName = "Set Mouse Position", Keywords = "mouse" ))

    ENGINE_API void SetMouseLocation( const int X, const int Y );


    ENGINE_API virtual void UpdateRotation(float DeltaTime);


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    virtual bool IsStreamingSourceEnabled() const { return bEnableStreamingSource; }


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    virtual bool StreamingSourceShouldActivate() const { return bEnableStreamingSource && bStreamingSourceShouldActivate; }


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    virtual bool StreamingSourceShouldBlockOnSlowStreaming() const { return bEnableStreamingSource && bStreamingSourceShouldBlockOnSlowStreaming; }


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    virtual EStreamingSourcePriority GetStreamingSourcePriority() const { return StreamingSourcePriority; }


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    ENGINE_API virtual void GetStreamingSourceLocationAndRotation(FVector& OutLocation, FRotator& OutRotation) const;


    UFUNCTION(BlueprintCallable, Category = WorldPartition)

    ENGINE_API virtual void GetStreamingSourceShapes(TArray<FStreamingSourceShape>& OutShapes) const;


    ENGINE_API virtual bool GetStreamingSources(TArray<FWorldPartitionStreamingSource>& OutStreamingSources) const final;


protected:

    ENGINE_API virtual bool GetStreamingSourcesInternal(TArray<FWorldPartitionStreamingSource>& OutStreamingSources) const;

    ENGINE_API virtual bool GetStreamingSource(FWorldPartitionStreamingSource& OutStreamingSource) const final;

    virtual const UObject* GetStreamingSourceOwner() const override final { return this; }


    ENGINE_API virtual void BeginPlayingState();


    ENGINE_API virtual void EndPlayingState();


    ENGINE_API virtual bool HasNetOwner() const override;


public:

    UFUNCTION(exec)

    ENGINE_API virtual void StartFire(uint8 FireModeNum = 0);


    ENGINE_API void LevelStreamingStatusChanged(class ULevelStreaming* LevelObject, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int32 LODIndex);

    ENGINE_API void LevelStreamingStatusChanged(class ULevelStreaming* LevelObject, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, bool bNewShouldBlockOnUnload, int32 LODIndex);


    ENGINE_API virtual void DelayedPrepareMapChange();


    ENGINE_API virtual void GetSeamlessTravelActorList(bool bToEntry, TArray<class AActor*>& ActorList);


    ENGINE_API virtual void SeamlessTravelTo(class APlayerController* NewPC);


    ENGINE_API virtual void SeamlessTravelFrom(class APlayerController* OldPC);


    ENGINE_API virtual void PostSeamlessTravel();


    ENGINE_API void OnAddedToPlayerControllerList();


    ENGINE_API void OnRemovedFromPlayerControllerList();


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientEnableNetworkVoice(bool bEnable);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientAckUpdateLevelVisibility(FName PackageName, FNetLevelVisibilityTransactionId TransactionId, bool bClientAckCanMakeVisible);


    ENGINE_API void StartTalking();


    ENGINE_API void StopTalking();


    UFUNCTION(exec)

    ENGINE_API virtual void ToggleSpeaking(bool bInSpeaking);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientVoiceHandshakeComplete();


    UFUNCTION(server, reliable, WithValidation)

    ENGINE_API virtual void ServerMutePlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(server, reliable, WithValidation )

    ENGINE_API virtual void ServerUnmutePlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientMutePlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientUnmutePlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(server, reliable, WithValidation)

    ENGINE_API virtual void ServerBlockPlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(server, reliable, WithValidation)

    ENGINE_API virtual void ServerUnblockPlayer(FUniqueNetIdRepl PlayerId);


    UFUNCTION(Reliable, Client)

    ENGINE_API virtual void ClientUnmutePlayers(const TArray<FUniqueNetIdRepl>& PlayerIds);


    ENGINE_API void GameplayMutePlayer(const FUniqueNetIdRepl& PlayerNetId);


    ENGINE_API void GameplayUnmutePlayer(const FUniqueNetIdRepl& PlayerNetId);


    ENGINE_API void GameplayUnmuteAllPlayers();


    ENGINE_API virtual class APlayerController* GetPlayerControllerForMuting(const FUniqueNetIdRepl& PlayerNetId);


    ENGINE_API virtual bool IsPlayerMuted(const class FUniqueNetId& PlayerId);


    UFUNCTION(exec)

    ENGINE_API virtual void ConsoleKey(FKey Key);


    UFUNCTION(exec)

    ENGINE_API virtual void SendToConsole(const FString& Command);


    UFUNCTION(reliable, client, SealedEvent)

    ENGINE_API void ClientAddTextureStreamingLoc(FVector InLoc, float Duration, bool bOverrideLocation);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientCancelPendingMapChange();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientCapBandwidth(int32 Cap);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientCommitMapChange();


    UFUNCTION(reliable, client, SealedEvent)

    ENGINE_API void ClientFlushLevelStreaming();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientForceGarbageCollection();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientGameEnded(class AActor* EndGameFocus, bool bIsWinner);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientGotoState(FName NewState);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientIgnoreLookInput(bool bIgnore);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientIgnoreMoveInput(bool bIgnore);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientMessage(const FString& S, FName Type = NAME_None, float MsgLifeTime = 0.f);


    UFUNCTION(unreliable, client, BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientStartCameraShake(TSubclassOf<class UCameraShakeBase> Shake, float Scale = 1.f, ECameraShakePlaySpace PlaySpace = ECameraShakePlaySpace::CameraLocal, FRotator UserPlaySpaceRot = FRotator::ZeroRotator);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientStartCameraShakeFromSource(TSubclassOf<class UCameraShakeBase> Shake, class UCameraShakeSourceComponent* SourceComponent);


    UFUNCTION(unreliable, client)

    ENGINE_API void ClientPlaySound(class USoundBase* Sound, float VolumeMultiplier = 1.f, float PitchMultiplier = 1.f );


    UFUNCTION(unreliable, client)

    ENGINE_API void ClientPlaySoundAtLocation(class USoundBase* Sound, FVector Location, float VolumeMultiplier = 1.f, float PitchMultiplier = 1.f);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientPrepareMapChange(FName LevelName, bool bFirst, bool bLast);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientPrestreamTextures(class AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int32 CinematicTextureGroups = 0);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientReset();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientRestart(class APawn* NewPawn);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetBlockOnAsyncLoading();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetCameraFade(bool bEnableFading, FColor FadeColor = FColor(ForceInit), FVector2D FadeAlpha = FVector2D(-1.0f, 0.0f), float FadeTime = 0, bool bFadeAudio = false, bool bHoldWhenFinished = false);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetCameraMode(FName NewCamMode);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetForceMipLevelsToBeResident(class UMaterialInterface* Material, float ForceDuration, int32 CinematicTextureGroups = 0);


    UFUNCTION(BlueprintCallable, Category="HUD", Reliable, Client)

    ENGINE_API void ClientSetHUD(TSubclassOf<AHUD> NewHUDClass);


    UFUNCTION(BlueprintCallable, Category="HUD")

    ENGINE_API void GetViewportSize(int32& SizeX, int32& SizeY) const;


    UFUNCTION(BlueprintCallable, Category="HUD")

    ENGINE_API AHUD* GetHUD() const;


    template<class T>


    T* GetHUD() const

    {

        return Cast<T>(MyHUD);

    }


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API void SetMouseCursorWidget(EMouseCursor::Type Cursor, UPARAM(Required) class UUserWidget* CursorWidget);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientSetViewTarget(class AActor* A, struct FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams());


    UFUNCTION(unreliable, client, BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientSpawnGenericCameraLensEffect(UPARAM(meta=(MustImplement ="CameraLensEffectInterface")) TSubclassOf<class AActor>  LensEffectEmitterClass);


    UFUNCTION(unreliable, client, Category="Game|Feedback", meta=(DeprecatedFunction, DeprecationMessage="Prefer the version taking ICameraLensEffectInterface (ClientSpawnGenericCameraLensEffect)"))

    ENGINE_API void ClientSpawnCameraLensEffect(TSubclassOf<class AEmitterCameraLensEffectBase>  LensEffectEmitterClass);


    UFUNCTION(reliable, client, BlueprintCallable, Category="Game|Feedback")

    ENGINE_API virtual void ClientClearCameraLensEffects();


    UFUNCTION(reliable, client, BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientStopCameraShake(TSubclassOf<class UCameraShakeBase> Shake, bool bImmediately = true);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientStopCameraShakesFromSource(class UCameraShakeSourceComponent* SourceComponent, bool bImmediately = true);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback", meta=(DisplayName="Client Play Force Feedback", AdvancedDisplay="bIgnoreTimeDilation,bPlayWhilePaused"))

    ENGINE_API void K2_ClientPlayForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, FName Tag, bool bLooping, bool bIgnoreTimeDilation, bool bPlayWhilePaused);


private:

    UFUNCTION(unreliable, client)

    ENGINE_API void ClientPlayForceFeedback_Internal(class UForceFeedbackEffect* ForceFeedbackEffect, FForceFeedbackParameters Params = FForceFeedbackParameters());


public:


    void ClientPlayForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, FForceFeedbackParameters Params = FForceFeedbackParameters())

    {

        ClientPlayForceFeedback_Internal(ForceFeedbackEffect, Params);

    }


    UFUNCTION(reliable, client, BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ClientStopForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, FName Tag);


public:

    UFUNCTION(BlueprintCallable, meta=(Latent, LatentInfo="LatentInfo", ExpandEnumAsExecs="Action", Duration="-1", bAffectsLeftLarge="true", bAffectsLeftSmall="true", bAffectsRightLarge="true", bAffectsRightSmall="true", AdvancedDisplay="bAffectsLeftLarge,bAffectsLeftSmall,bAffectsRightLarge,bAffectsRightSmall"), Category="Game|Feedback")

    ENGINE_API void PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, TEnumAsByte<EDynamicForceFeedbackAction::Type> Action, FLatentActionInfo LatentInfo);


private:

    //~ This method is purely for debugging purposes.

    //~ It will trigger a ServerUpdateLevelVisibilityCall with the provided package name.

    UFUNCTION(Exec)

    ENGINE_API void TestServerLevelVisibilityChange(const FName PackageName, const FName FileName);


public:

    ENGINE_API FDynamicForceFeedbackHandle PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, EDynamicForceFeedbackAction::Type Action = EDynamicForceFeedbackAction::Start, FDynamicForceFeedbackHandle ActionHandle = 0);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void PlayHapticEffect(class UHapticFeedbackEffect_Base* HapticEffect, EControllerHand Hand, float Scale = 1.f,  bool bLoop = false);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void StopHapticEffect(EControllerHand Hand);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void SetHapticsByValue(const float Frequency, const float Amplitude, EControllerHand Hand);


    UFUNCTION(BlueprintCallable, Category = "Game|Feedback")

    ENGINE_API virtual void SetDisableHaptics(bool bNewDisabled);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void SetControllerLightColor(FColor Color);


    UFUNCTION(BlueprintCallable, Category="Game|Feedback")

    ENGINE_API void ResetControllerLightColor();


    UFUNCTION(BlueprintCallable, Category = "Input")

    ENGINE_API void SetControllerDeadZones(const float LeftDeadZone, const float RightDeadZone);


    UFUNCTION(BlueprintCallable, Category = "Input")

    ENGINE_API void ResetControllerDeadZones();


    UFUNCTION(BlueprintCallable, Category = "Input")

    ENGINE_API void SetControllerTriggerReleaseThresholds(const float LeftThreshold, const float RightThreshold);


    UFUNCTION(BlueprintCallable, Category = "Input")

    ENGINE_API void ResetControllerTriggerReleaseThresholds();


    UFUNCTION(BlueprintCallable, Category = "Input")

    ENGINE_API void SetControllerGyroAutoCalibration(bool bEnabled);


    UFUNCTION()

    ENGINE_API void ClientTravel(const FString& URL, enum ETravelType TravelType, bool bSeamless = false, FGuid MapPackageGuid = FGuid());


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientTravelInternal(const FString& URL, enum ETravelType TravelType, bool bSeamless = false, FGuid MapPackageGuid = FGuid());


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientUpdateLevelStreamingStatus(FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int32 LODIndex, FNetLevelVisibilityTransactionId TransactionId = FNetLevelVisibilityTransactionId(), bool bNewShouldBlockOnUnload = false);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientUpdateMultipleLevelsStreamingStatus(const TArray<FUpdateLevelStreamingLevelStatus>& LevelStatuses);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientWasKicked(const FText& KickReason);


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientStartOnlineSession();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientEndOnlineSession();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientRetryClientRestart(class APawn* NewPawn);


    ENGINE_API virtual void SafeRetryClientRestart();


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientReceiveLocalizedMessage(TSubclassOf<ULocalMessage> Message, int32 Switch = 0, class APlayerState* RelatedPlayerState_1 = nullptr, class APlayerState* RelatedPlayerState_2 = nullptr, class UObject* OptionalObject = nullptr);


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerAcknowledgePossession(class APawn* P);


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerCamera(FName NewMode);


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerChangeName(const FString& S);


    UFUNCTION(reliable, server, WithValidation, SealedEvent)

    ENGINE_API void ServerNotifyLoadedWorld(FName WorldPackageName);


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerPause();


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerRestartPlayer();


    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerSetSpectatorLocation(FVector NewLoc, FRotator NewRot);


    ENGINE_API void SafeServerUpdateSpectatorState();


    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerCheckClientPossession();


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerCheckClientPossessionReliable();


    ENGINE_API virtual void SafeServerCheckClientPossession();


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerShortTimeout();


    // @TODO - combine pitch/yaw into one int, maybe also send location compressed

    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerUpdateCamera(FVector_NetQuantize CamLoc, int32 CamPitchAndYaw);


    UFUNCTION(reliable, server, WithValidation, SealedEvent)

    ENGINE_API void ServerUpdateLevelVisibility(const FUpdateLevelVisibilityLevelInfo& LevelVisibility);


    UFUNCTION(reliable, server, WithValidation, SealedEvent)

    ENGINE_API void ServerUpdateMultipleLevelsVisibility( const TArray<FUpdateLevelVisibilityLevelInfo>& LevelVisibilities );


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerVerifyViewTarget();


    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerViewNextPlayer();


    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerViewPrevPlayer();


    UFUNCTION(unreliable, server, WithValidation)

    ENGINE_API void ServerViewSelf(struct FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams());


    UFUNCTION(Reliable, Client)

    ENGINE_API void ClientTeamMessage(class APlayerState* SenderPlayerState, const FString& S, FName Type, float MsgLifeTime = 0);


    UFUNCTION(reliable, server, WithValidation)

    ENGINE_API void ServerToggleAILogging();


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(Keywords="up down"))

    ENGINE_API virtual void AddPitchInput(float Val);


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(Keywords="left right turn"))

    ENGINE_API virtual void AddYawInput(float Val);


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API virtual void AddRollInput(float Val);


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API bool IsInputKeyDown(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API bool WasInputKeyJustPressed(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API bool WasInputKeyJustReleased(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API float GetInputAnalogKeyState(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API FVector GetInputVectorKeyState(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API void GetInputTouchState(ETouchIndex::Type FingerIndex, float& LocationX, float& LocationY, bool& bIsCurrentlyPressed) const;

    ENGINE_API void GetInputTouchState(ETouchIndex::Type FingerIndex, double& LocationX, double& LocationY, bool& bIsCurrentlyPressed) const;   // LWC_TODO: Temp stand in for native calls with FVector2D components.


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API void GetInputMotionState(FVector& Tilt, FVector& RotationRate, FVector& Gravity, FVector& Acceleration) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API bool GetMousePosition(float& LocationX, float& LocationY) const;

    ENGINE_API bool GetMousePosition(double& LocationX, double& LocationY) const;   // LWC_TODO: Temp stand in for native calls with FVector2D components.


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API float GetInputKeyTimeDown(FKey Key) const;


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API void GetInputMouseDelta(float& DeltaX, float& DeltaY) const;

    ENGINE_API void GetInputMouseDelta(double& DeltaX, double& DeltaY) const;   // LWC_TODO: Temp stand in for native calls with FVector2D components.


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API void GetInputAnalogStickState(EControllerAnalogStick::Type WhichStick, float& StickX, float& StickY) const;

    ENGINE_API void GetInputAnalogStickState(EControllerAnalogStick::Type WhichStick, double& StickX, double& StickY) const;    // LWC_TODO: Temp stand in for native calls with FVector2D components.


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API virtual void ActivateTouchInterface(class UTouchInterface* NewTouchInterface);


    UFUNCTION(BlueprintCallable, Category="Game|Player")

    ENGINE_API virtual void SetVirtualJoystickVisibility(bool bVisible);


    ENGINE_API virtual void SetInputMode(const FInputModeDataBase& InData);


    UFUNCTION(exec)

    ENGINE_API virtual void Camera(FName NewMode);


    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(Keywords = "Camera"))

    ENGINE_API virtual void SetViewTargetWithBlend(class AActor* NewViewTarget, float BlendTime = 0, enum EViewTargetBlendFunction BlendFunc = VTBlend_Linear, float BlendExp = 0, bool bLockOutgoing = false);


    ENGINE_API void IncludeInNetConditionGroup(FName NetGroup);


    ENGINE_API void RemoveFromNetConditionGroup(FName NetGroup);


    bool IsMemberOfNetConditionGroup(FName NetGroup) const

    {

        return NetConditionGroups.Find(NetGroup) != INDEX_NONE;

    }


    const TArray<FName>& GetNetConditionGroups() const { return NetConditionGroups; }


private:


    TArray<FName> NetConditionGroups;


protected:

    TWeakObjectPtr<UPrimitiveComponent> CurrentClickablePrimitive;


    TWeakObjectPtr<UPrimitiveComponent> CurrentTouchablePrimitives[EKeys::NUM_TOUCH_KEYS];


    TArray< TWeakObjectPtr<UInputComponent> > CurrentInputStack;


    UPROPERTY()

    TObjectPtr<UInputComponent> InactiveStateInputComponent;


    ENGINE_API virtual void SetupInactiveStateInputComponent(UInputComponent* InComponent);


    ENGINE_API virtual void UpdateStateInputComponents();


    uint32 bCinemaDisableInputMove:1;

    uint32 bCinemaDisableInputLook:1;


    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerController)

    uint32 bShouldPerformFullTickWhenPaused : 1;


private:

    /* Whether the PlayerController's input handling is enabled. */

    uint32 bInputEnabled:1;


protected:


    TSharedPtr<class SVirtualJoystick> VirtualJoystick;


    ENGINE_API virtual TSharedPtr<class SVirtualJoystick> CreateVirtualJoystick();


    UPROPERTY()

    TObjectPtr<class UTouchInterface> CurrentTouchInterface;


    UPROPERTY(EditDefaultsOnly, Category = Input)

    TSubclassOf<UPlayerInput> OverridePlayerInputClass;


    FTimerHandle TimerHandle_UnFreeze;


private:

    FTimerHandle TimerHandle_DelayedPrepareMapChange;


    FTimerHandle TimerHandle_ClientCommitMapChange;


public:

    ENGINE_API virtual void PushInputComponent(UInputComponent* Input);


    ENGINE_API virtual bool PopInputComponent(UInputComponent* Input);


    ENGINE_API virtual bool IsInputComponentInStack(const UInputComponent* Input) const;


    ENGINE_API virtual void FlushPressedKeys();


    virtual bool ShouldFlushKeysWhenViewportFocusChanges() const { return bShouldFlushInputWhenViewportFocusChanges; }


    UFUNCTION(BlueprintCallable, Category = Input)

    ENGINE_API TSubclassOf<UPlayerInput> GetOverridePlayerInputClass() const;


    UE_DEPRECATED(5.6, "Use the version which takes a FInputKeyEventArgs instead.")

    PRAGMA_DISABLE_DEPRECATION_WARNINGS

    ENGINE_API virtual bool InputKey(const FInputKeyParams& Params) final;

    PRAGMA_ENABLE_DEPRECATION_WARNINGS


    ENGINE_API virtual bool InputKey(const FInputKeyEventArgs& Params);


    UE_DEPRECATED(5.6, "Use the version which takes in a DeviceId and Timestamp instead.")

    ENGINE_API virtual bool InputTouch(uint32 Handle, ETouchType::Type Type, const FVector2D& TouchLocation, float Force, FDateTime DeviceTimestamp, uint32 TouchpadIndex) final;


    ENGINE_API virtual bool InputTouch(

        const FInputDeviceId DeviceId,

        uint32 Handle,

        ETouchType::Type Type,

        const FVector2D& TouchLocation,

        float Force,

        uint32 TouchpadIndex,

        const uint64 Timestamp);


    UE_DEPRECATED(5.6, "Use the version which takes in a DeviceId and Timestamp instead.")

    ENGINE_API virtual bool InputMotion(const FVector& Tilt, const FVector& RotationRate, const FVector& Gravity, const FVector& Acceleration) final;


    ENGINE_API virtual bool InputMotion(const FInputDeviceId DeviceId, const FVector& Tilt, const FVector& RotationRate, const FVector& Gravity, const FVector& Acceleration, const uint64 Timestamp);


    ENGINE_API virtual void SetPlayer(UPlayer* InPlayer);


    ENGINE_API class ULocalPlayer* GetLocalPlayer() const;


    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Game|Player")

    ENGINE_API FPlatformUserId GetPlatformUserId() const;


    ENGINE_API virtual void SmoothTargetViewRotation(APawn* TargetPawn, float DeltaSeconds);


    ENGINE_API virtual FString ConsoleCommand(const FString& Command, bool bWriteToLog = true);


    //~ Begin UObject Interface

    ENGINE_API virtual void PostLoad() override;

    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const override;

#if UE_WITH_REMOTE_OBJECT_HANDLE

    ENGINE_API virtual void PostMigrate(const FUObjectMigrationContext& MigrationContext) override;

#endif

    //~ End UObject Interface


    //~ Begin AActor Interface

    ENGINE_API virtual void GetActorEyesViewPoint(FVector& Location, FRotator& Rotation) const override;

    ENGINE_API virtual void CalcCamera(float DeltaTime, struct FMinimalViewInfo& OutResult) override;

    ENGINE_API virtual void TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction) override;

    ENGINE_API virtual bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const FVector& SrcLocation) const override;

    ENGINE_API virtual void FellOutOfWorld(const class UDamageType& dmgType) override;

    ENGINE_API virtual void Reset() override;

protected:

    ENGINE_API virtual void OnPossess(APawn* aPawn) override;

    ENGINE_API virtual void OnUnPossess() override;

public:

    ENGINE_API virtual void CleanupPlayerState() override;

    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

    ENGINE_API virtual void Destroyed() override;

    ENGINE_API virtual void OnActorChannelOpen(class FInBunch& InBunch, class UNetConnection* Connection) override;

    ENGINE_API virtual bool UseShortConnectTimeout() const override;

    ENGINE_API virtual void OnSerializeNewActor(class FOutBunch& OutBunch) override;

    ENGINE_API virtual void OnNetCleanup(class UNetConnection* Connection) override;

    ENGINE_API virtual float GetNetPriority(const FVector& ViewPos, const FVector& ViewDir, AActor* Viewer, AActor* ViewTarget, UActorChannel* InChannel, float Time, bool bLowBandwidth) override;

    ENGINE_API virtual const AActor* GetNetOwner() const override;

    ENGINE_API virtual class UPlayer* GetNetOwningPlayer() override;

    ENGINE_API virtual class UPlayer* GetNetOwningPlayerAnyRole() override;

    ENGINE_API virtual class UNetConnection* GetNetConnection() const override;

    ENGINE_API virtual bool DestroyNetworkActorHandled() override;

    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;

    ENGINE_API virtual void PostInitializeComponents() override;

    ENGINE_API virtual void EnableInput(class APlayerController* PlayerController) override;

    ENGINE_API virtual void DisableInput(class APlayerController* PlayerController) override;


    ENGINE_API virtual void Serialize(FArchive& Ar) override;


protected:

    ENGINE_API virtual void BeginPlay() override;

    //~ End AActor Interface


public:

    //~ Begin AController Interface

    ENGINE_API virtual void GameHasEnded(class AActor* EndGameFocus = nullptr, bool bIsWinner = false) override;

    ENGINE_API virtual bool IsLocalController() const override;

    ENGINE_API virtual void GetPlayerViewPoint(FVector& out_Location, FRotator& out_Rotation) const override;

    ENGINE_API virtual void SetInitialLocationAndRotation(const FVector& NewLocation, const FRotator& NewRotation) override;

    ENGINE_API virtual void ChangeState(FName NewState) override;

    ENGINE_API virtual class AActor* GetViewTarget() const override;

    ENGINE_API virtual void BeginInactiveState() override;

    ENGINE_API virtual void EndInactiveState() override;

    ENGINE_API virtual void FailedToSpawnPawn() override;

    ENGINE_API virtual void SetPawn(APawn* InPawn) override;

    //~ End AController Interface


    virtual void NotifyActorChannelFailure(UActorChannel* ActorChan) {}


    virtual void UpdateHiddenActors(const FVector& ViewLocation) {}


    virtual void UpdateHiddenComponents(const FVector& ViewLocation, TSet<FPrimitiveComponentId>& /*HiddenComponents*/) {}


    ENGINE_API void BuildHiddenComponentList(const FVector& ViewLocation, TSet<FPrimitiveComponentId>& HiddenComponentsOut);


    ENGINE_API virtual void SpawnPlayerCameraManager();


    ENGINE_API virtual void GetAudioListenerPosition(FVector& OutLocation, FVector& OutFrontDir, FVector& OutRightDir) const;


    ENGINE_API virtual bool GetAudioListenerAttenuationOverridePosition(FVector& OutLocation) const;


    UFUNCTION(BlueprintCallable, Category="Game|Audio")

    ENGINE_API void SetAudioListenerOverride(USceneComponent* AttachToComponent, FVector Location, FRotator Rotation);


    UFUNCTION(BlueprintCallable, Category="Game|Audio")

    ENGINE_API void ClearAudioListenerOverride();


    UFUNCTION(BlueprintCallable, Category = "Game|Audio")

    ENGINE_API void SetAudioListenerAttenuationOverride(USceneComponent* AttachToComponent, FVector AttenuationLocationOVerride);


    UFUNCTION(BlueprintCallable, Category = "Game|Audio")

    ENGINE_API void ClearAudioListenerAttenuationOverride();


protected:

    uint32 bOverrideAudioListener:1;

    uint32 bOverrideAudioAttenuationListener:1;

    TWeakObjectPtr<USceneComponent> AudioListenerComponent;

    TWeakObjectPtr<USceneComponent> AudioListenerAttenuationComponent;

    FVector AudioListenerLocationOverride;

    FRotator AudioListenerRotationOverride;

    FVector AudioListenerAttenuationOverride;


    ENGINE_API void TickPlayerInput(const float DeltaSeconds, const bool bGamePaused);

    ENGINE_API virtual void ProcessPlayerInput(const float DeltaTime, const bool bGamePaused);

    ENGINE_API virtual void BuildInputStack(TArray<UInputComponent*>& InputStack);

    ENGINE_API void ProcessForceFeedbackAndHaptics(const float DeltaTime, const bool bGamePaused);

    ENGINE_API virtual void UpdateForceFeedback(IInputInterface* InputInterface, const int32 ControllerId);

    ENGINE_API virtual bool IsInViewportClient(UGameViewportClient* ViewportClient) const;

    ENGINE_API virtual int32 GetInputIndex() const;

    ENGINE_API virtual ACameraActor* GetAutoActivateCameraForPlayer() const;

    ENGINE_API virtual void ProcessTouchHitResult(const FInputDeviceId DeviceId, uint32 Handle, ETouchType::Type Type, const FVector2D& TouchLocation, const FHitResult& HitResult, const bool bHit);


    ENGINE_API virtual void SetupInputComponent();


public:

    ENGINE_API void SetNetSpeed(int32 NewSpeed);


    ENGINE_API FString GetPlayerNetworkAddress();


    ENGINE_API FString GetServerNetworkAddress();


    ENGINE_API FName NetworkRemapPath(FName InPackageName, bool bReading);


    ENGINE_API virtual void CleanUpAudioComponents();


    ENGINE_API virtual void AddCheats(bool bForce = false);


    ENGINE_API virtual void SpawnDefaultHUD();


    ENGINE_API virtual void CreateTouchInterface();


    ENGINE_API virtual void CleanupGameViewport();


    ENGINE_API virtual void AcknowledgePossession(class APawn* P);


    ENGINE_API virtual void PawnLeavingGame();


    ENGINE_API virtual void UpdatePing(float InPing);


    ENGINE_API virtual class APlayerState* GetNextViewablePlayer(int32 dir);


    ENGINE_API virtual void ViewAPlayer(int32 dir);


    UFUNCTION(BlueprintCallable, Category = "Game|Player")

    ENGINE_API virtual bool CanRestartPlayer();


    UFUNCTION(BlueprintCallable, Category="Game|Cinematic", meta=(bHidePlayer="true", bAffectsHUD="true"))

    ENGINE_API virtual void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning);


    ENGINE_API bool IsSplitscreenPlayer(int32* OutSplitscreenPlayerIndex = nullptr) const;


    UFUNCTION(BlueprintPure, Category = "Game|Player")

    ENGINE_API bool IsPrimaryPlayer() const;


    ENGINE_API class APlayerState* GetSplitscreenPlayerByIndex(int32 PlayerIndex = 1) const;


    ENGINE_API int32 GetSplitscreenPlayerCount() const;


    ENGINE_API virtual void UpdateCameraManager(float DeltaSeconds);


    ENGINE_API virtual void ReceivedGameModeClass(TSubclassOf<class AGameModeBase> GameModeClass);


    ENGINE_API virtual bool NotifyServerReceivedClientData(APawn* InPawn, float TimeStamp);


    ENGINE_API virtual void StartSpectatingOnly();


    ENGINE_API virtual bool DefaultCanUnpause();


    ENGINE_API bool IsPaused() const;


    bool InputEnabled() const { return bInputEnabled; }


    ENGINE_API bool ShouldPerformFullTickWhenPaused() const;


    ENGINE_API bool HasClientLoadedCurrentWorld();


    UE_DEPRECATED(5.3, "Deprecated in favor of using ForceNetUpdate on the target actor instead.")

    ENGINE_API void ForceSingleNetUpdateFor(class AActor* Target);


    ENGINE_API virtual void SetViewTarget(class AActor* NewViewTarget, FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams());


    ENGINE_API virtual void AutoManageActiveCameraTarget(AActor* SuggestedTarget);


    UFUNCTION(Reliable, Client)

    ENGINE_API void OnServerStartedVisualLogger(bool bIsLogging);


    ENGINE_API void SetShowMouseCursor(bool bShow);


    ENGINE_API virtual bool ShouldShowMouseCursor() const;


    ENGINE_API virtual EMouseCursor::Type GetMouseCursor() const;


    // Spectating


    UFUNCTION(BlueprintCallable, Category=Pawn)

    ASpectatorPawn* GetSpectatorPawn() const { return SpectatorPawn; }


    ENGINE_API APawn* GetPawnOrSpectator() const;


    ENGINE_API virtual void ReceivedSpectatorClass(TSubclassOf<ASpectatorPawn> SpectatorClass);


    UFUNCTION(BlueprintCallable, Category=Pawn)

    ENGINE_API virtual FVector GetFocalLocation() const;


protected:

    ENGINE_API virtual void BeginSpectatingState();


    ENGINE_API virtual void EndSpectatingState();


    ENGINE_API virtual void SetSpectatorPawn(ASpectatorPawn* NewSpectatorPawn);


    ENGINE_API virtual ASpectatorPawn* SpawnSpectatorPawn();


    ENGINE_API virtual void DestroySpectatorPawn();


    virtual bool ShouldKeepCurrentPawnUponSpectating() const { return false; }


private:

    UPROPERTY()

    TObjectPtr<ASpectatorPawn> SpectatorPawn;


    float       LastRetryPlayerTime;


    UPROPERTY()

    mutable bool bIsLocalPlayerController;


protected:

    UPROPERTY(Replicated)

    FVector SpawnLocation;


    ENGINE_API virtual void SetSpawnLocation(const FVector& NewLocation);


    float LastMovementUpdateTime;


    float LastMovementHitch;


public:

    FVector GetSpawnLocation() const { return SpawnLocation; }


    ENGINE_API virtual void ReceivedPlayer();


    ENGINE_API virtual void InitInputSystem();


    ENGINE_API virtual bool IsFrozen();


    ENGINE_API virtual void PreClientTravel(const FString& PendingURL, ETravelType TravelType, bool bIsSeamlessTravel);


    ENGINE_API virtual void SetCameraMode(FName NewCamMode);


    ENGINE_API virtual void ResetCameraMode();


    ENGINE_API virtual void SendClientAdjustment();


    void SetAsLocalPlayerController() { bIsLocalPlayerController = true; }


    virtual bool ShouldParticipateInSeamlessTravel() const override { return true; }


#if UE_ENABLE_DEBUG_DRAWING

    ENGINE_API const FString& GetCurrentInputModeDebugString() const;

#endif


private:

    bool bDisableHaptics : 1;


    bool bShouldFlushInputWhenViewportFocusChanges : 1;


#if UE_ENABLE_DEBUG_DRAWING

    FString CurrentInputModeDebugString;

#endif


    int32 NetworkPhysicsTickOffset = 0;

    bool bNetworkPhysicsTickOffsetAssigned = false;


    float TickOffsetSyncCountdown = 0.f;


    float NetworkPhysicsTickOffsetDesyncAccumulatedTime = 0.0f;


public:


    ENGINE_API void UpdateServerAsyncPhysicsTickOffset();


    UFUNCTION(Server, Unreliable)

    ENGINE_API void ServerSendLatestAsyncPhysicsTimestamp(FAsyncPhysicsTimestamp Timestamp);


    UFUNCTION(Client, Reliable)

    ENGINE_API void ClientSetupNetworkPhysicsTimestamp(FAsyncPhysicsTimestamp Timestamp);


    UFUNCTION(Client, Unreliable)

    ENGINE_API void ClientAckTimeDilation(float TimeDilation, int32 ServerStep);


    ENGINE_API void ExecuteAsyncPhysicsCommand(const FAsyncPhysicsTimestamp& AsyncPhysicsTimestamp, UObject* OwningObject, const TFunction<void()>& Command, const bool bEnableResim = true);


    ENGINE_API FAsyncPhysicsTimestamp GetPhysicsTimestamp();


    UE_DEPRECATED(5.7, "Deprecated, use the GetPhysicsTimestamp() without the DeltaSeconds parameter, it will return the upcoming frame as intended.")

    FAsyncPhysicsTimestamp GetPhysicsTimestamp(float DeltaSeconds) { return GetPhysicsTimestamp(); }


    int32 GetNetworkPhysicsTickOffset() const { return NetworkPhysicsTickOffset; }


    bool GetNetworkPhysicsTickOffsetAssigned() const { return bNetworkPhysicsTickOffsetAssigned; }


    ENGINE_API uint32 GetClientHandshakeId() const;


    ENGINE_API void SetClientHandshakeId(uint32 InClientHandshakeId);


    ENGINE_API void SetLocalPlayerConnectionIdentifier(int32 Identifier);


    ENGINE_API int32 GetLocalPlayerConnectionIdentifier() const;


private:


    UPROPERTY()

    FUniqueNetIdRepl CachedConnectionPlayerId;


    UPROPERTY(DuplicateTransient)

    uint32 ClientHandshakeId = 0;


    int32 LocalPlayerConnectionIdentifier;

};


UCLASS(MinimalAPI)


class ANoPawnPlayerController : public APlayerController

{

public:


    GENERATED_BODY()

    ANoPawnPlayerController(const FObjectInitializer& ObjectInitializer);


    virtual void PostInitializeComponents() override;

    virtual class AActor* GetViewTarget() const override;

    virtual class UNetConnection* GetNetConnection() const override;


    UFUNCTION(Server, Unreliable)

    void ServerSetViewTargetPosition(FVector ViewTargetPos);


    UFUNCTION(Server, Reliable)

    void ServerEnableReplicationToConnection(bool bEnable);


    bool IsEnableReplicationToConnection() const { return bEnableReplicationToConnection; }


private:


    bool bEnableReplicationToConnection = true;

};


EARWorldAlignment::Gravity
@ Gravity

EARWorldAlignment::Camera
@ Camera

EARSessionType::World
@ World

EMontagePlayReturnType::Duration
@ Duration

EScaleChainInitialLength::Distance
@ Distance

ESplineBoneAxis::Y
@ Y

PlayerIndex
PlayerIndex
Definition AppleControllerInterface.h:24

EAsyncPackageLoadingState2::PostLoad
@ PostLoad

AsyncPhysicsData.h

EMusicalNoteName::A
@ A

EAudioParameterType::Object
@ Object

EBTBranchAction::All
@ All

ECameraShakePlaySpace
ECameraShakePlaySpace
Definition CameraTypes.h:26

ECameraShakePlaySpace::CameraLocal
@ CameraLocal

ECborCode::Tag
@ Tag

EChaosPerfUnits::S
@ S

EChaosVDManifoldPointFlags::IsValid
@ IsValid

ETransformConstraintType::Scale
@ Scale

ETransformConstraintType::Rotation
@ Rotation

Controller.h

INDEX_NONE
@ INDEX_NONE
Definition CoreMiscDefines.h:150

ForceInit
@ ForceInit
Definition CoreMiscDefines.h:155

UE_DEPRECATED
#define UE_DEPRECATED(Version, Message)
Definition CoreMiscDefines.h:302

TEXT
#define TEXT(x)
Definition Platform.h:1272

int32
FPlatformTypes::int32 int32
A 32-bit signed integer.
Definition Platform.h:1125

uint64
FPlatformTypes::uint64 uint64
A 64-bit unsigned integer.
Definition Platform.h:1117

DECLARE_STATS_GROUP
#define DECLARE_STATS_GROUP(GroupDesc, GroupId, GroupCat)
Definition Stats.h:689

StaticCastSharedRef
UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
Definition SharedPointer.h:127

ETransformCurveChannel::Position
@ Position

ED3D12BarrierImplementationType::Enhanced
@ Enhanced

EDatasmithElementType::Material
@ Material

EDatasmithCompositeCompMode::Screen
@ Screen

DECLARE_DELEGATE_RetVal
#define DECLARE_DELEGATE_RetVal(ReturnValueType, DelegateName)
Definition DelegateCombinations.h:41

DECLARE_DELEGATE_ThreeParams
#define DECLARE_DELEGATE_ThreeParams(DelegateName, Param1Type, Param2Type, Param3Type)
Definition DelegateCombinations.h:66

EngineBaseTypes.h

EMouseLockMode
EMouseLockMode
Definition EngineBaseTypes.h:57

ELevelTick
ELevelTick
Definition EngineBaseTypes.h:70

ETravelType
ETravelType
Definition EngineBaseTypes.h:726

EngineDefines.h

EngineTypes.h

EObjectTypeQuery
EObjectTypeQuery
Definition EngineTypes.h:1160

ETraceTypeQuery
ETraceTypeQuery
Definition EngineTypes.h:1200

ECollisionChannel
ECollisionChannel
Definition EngineTypes.h:1088

EPackageAutoSaveType::Transient
@ Transient

true
return true
Definition ExternalRpcRegistry.cpp:601

ForceFeedbackParameters.h

X
#define X(Name, Desc)
Definition FormatStringSan.h:47

EGPUProfileSortMode::TimeElapsed
@ TimeElapsed

EGameplayDebuggerInputMode::Replicated
@ Replicated

PRAGMA_ENABLE_DEPRECATION_WARNINGS
#define PRAGMA_ENABLE_DEPRECATION_WARNINGS
Definition GenericPlatformCompilerPreSetup.h:12

PRAGMA_DISABLE_DEPRECATION_WARNINGS
#define PRAGMA_DISABLE_DEPRECATION_WARNINGS
Definition GenericPlatformCompilerPreSetup.h:8

EBuildTargetType::Client
@ Client

EBuildTargetType::Game
@ Game

EBuildTargetType::Server
@ Server

Guid.h

EXRVisualType::Hand
@ Hand

EXRTrackedDeviceType::Controller
@ Controller

ICursor.h

IInputInterface.h

EMediaControl::Pause
@ Pause

EMessageFlags::Reliable
@ Reliable

ECursorMoveMethod::ScreenPosition
@ ScreenPosition

InputCoreTypes.h

EControllerHand
EControllerHand
Definition InputCoreTypes.h:17

InputKeyEventArgs.h

EInputDevices::Mouse
@ Mouse

EJsonToken::Identifier
@ Identifier

LatentActionManager.h

DECLARE_LOG_CATEGORY_EXTERN
#define DECLARE_LOG_CATEGORY_EXTERN(CategoryName, DefaultVerbosity, CompileTimeVerbosity)
Definition LogMacros.h:361

EMaterialExpressionConvertType::Scalar
@ Scalar

NetSerialization.h

bool
const bool
Definition NetworkReplayStreaming.h:178

ObjectMacros.h

UPROPERTY
#define UPROPERTY(...)
UObject definition macros.
Definition ObjectMacros.h:744

UPARAM
#define UPARAM(...)
Definition ObjectMacros.h:748

GENERATED_BODY
#define GENERATED_BODY(...)
Definition ObjectMacros.h:765

UFUNCTION
#define UFUNCTION(...)
Definition ObjectMacros.h:745

UCLASS
#define UCLASS(...)
Definition ObjectMacros.h:776

UENUM
#define UENUM(...)
Definition ObjectMacros.h:749

USTRUCT
#define USTRUCT(...)
Definition ObjectMacros.h:746

OnlineReplStructs.h

EPerQualityLevels::Cinematic
@ Cinematic

bTraceComplex
const bool bTraceComplex
Definition PhysicsInterfaceUtils.h:19

PlayerCameraManager.h

EViewTargetBlendFunction
EViewTargetBlendFunction
Definition PlayerCameraManager.h:30

VTBlend_Linear
@ VTBlend_Linear
Definition PlayerCameraManager.h:32

FDynamicForceFeedbackHandle
uint64 FDynamicForceFeedbackHandle
Definition PlayerController.h:77

PlayerMuteList.h

Stop
@ Stop
Definition PrecomputedVolumetricLightmapStreaming.cpp:26

EPrintStaleReferencesOptions::Log
@ Log

EAccelerationStructureBuildMode::Update
@ Update

left
bool left(const int *a, const int *b, const int *c)
Definition RecastMesh.cpp:182

EGeometryCollectionCacheType::Play
@ Play

ESerializePropertyType::Handle
@ Handle

SceneTypes.h

SlateFwd.h

SortedMap.h

EConcurrencyMode::Sound
@ Sound

StaticArray.h

EPropertyBagContainerType::Set
@ Set

EStyleColor::Input
@ Input

SubclassOf.h

TextProperty.h

EUnitType::Acceleration
@ Acceleration

EUnitType::Frequency
@ Frequency

EUnitType::Force
@ Force

EUnitType::Time
@ Time

Val
float Val(const FString &Value)
Definition UnrealMath.cpp:3163

UpdateLevelVisibilityLevelInfo.h

EVariantTypes::Color
@ Color

EVulkanQueryPoolType::Timestamp
@ Timestamp

WorldPartitionStreamingSource.h

EStreamingSourcePriority
EStreamingSourcePriority
Definition WorldPartitionStreamingSource.h:331

uint8
uint8_t uint8
Definition binka_ue_file_header.h:8

uint16
uint16_t uint16
Definition binka_ue_file_header.h:7

uint32
uint32_t uint32
Definition binka_ue_file_header.h:6

AActor
Definition Actor.h:257

AActor::PostInitializeComponents
virtual ENGINE_API void PostInitializeComponents()
Definition Actor.cpp:6544

AActor::AttachToComponent
ENGINE_API bool AttachToComponent(USceneComponent *Parent, const FAttachmentTransformRules &AttachmentRules, FName SocketName=NAME_None)
Definition Actor.cpp:2680

AActor::GetNetConnection
virtual ENGINE_API class UNetConnection * GetNetConnection() const
Definition Actor.cpp:1930

AActor::const
FName Tag const
Definition Actor.h:3810

AController
Definition Controller.h:41

AEmitterCameraLensEffectBase
Definition EmitterCameraLensEffectBase.h:21

ANoPawnPlayerController
Definition PlayerController.h:2354

APlayerCameraManager
Definition PlayerCameraManager.h:189

APlayerController
Definition PlayerController.h:261

APlayerController::GetPawnOrSpectator
ENGINE_API APawn * GetPawnOrSpectator() const

APlayerController::UseShortConnectTimeout
virtual ENGINE_API bool UseShortConnectTimeout() const override

APlayerController::ActiveHapticEffect_Right
TSharedPtr< struct FActiveHapticFeedbackEffect > ActiveHapticEffect_Right
Definition PlayerController.h:417

APlayerController::GetActorEyesViewPoint
virtual ENGINE_API void GetActorEyesViewPoint(FVector &Location, FRotator &Rotation) const override

APlayerController::DisableInput
virtual ENGINE_API void DisableInput(class APlayerController *PlayerController) override

APlayerController::GetNetConditionGroups
const TArray< FName > & GetNetConditionGroups() const
Definition PlayerController.h:1680

APlayerController::ForceFeedbackEffectHistoryEntries
TArray< FForceFeedbackEffectHistoryEntry > ForceFeedbackEffectHistoryEntries
Definition PlayerController.h:375

APlayerController::OnActorChannelOpen
virtual ENGINE_API void OnActorChannelOpen(class FInBunch &InBunch, class UNetConnection *Connection) override

APlayerController::Serialize
virtual ENGINE_API void Serialize(FArchive &Ar) override

APlayerController::SetClientHandshakeId
ENGINE_API void SetClientHandshakeId(uint32 InClientHandshakeId)

APlayerController::HasClientLoadedCurrentWorld
ENGINE_API bool HasClientLoadedCurrentWorld()

APlayerController::SetInitialLocationAndRotation
virtual ENGINE_API void SetInitialLocationAndRotation(const FVector &NewLocation, const FRotator &NewRotation) override

APlayerController::DisplayDebug
virtual ENGINE_API void DisplayDebug(class UCanvas *Canvas, const FDebugDisplayInfo &DebugDisplay, float &YL, float &YPos) override

APlayerController::ActiveHapticEffect_HMD
TSharedPtr< struct FActiveHapticFeedbackEffect > ActiveHapticEffect_HMD
Definition PlayerController.h:419

APlayerController::NotifyActorChannelFailure
virtual void NotifyActorChannelFailure(UActorChannel *ActorChan)
Definition PlayerController.h:1888

APlayerController::Reset
virtual ENGINE_API void Reset() override

APlayerController::Destroyed
virtual ENGINE_API void Destroyed() override

APlayerController::BeginPlay
virtual ENGINE_API void BeginPlay() override

APlayerController::PreClientTravel
virtual ENGINE_API void PreClientTravel(const FString &PendingURL, ETravelType TravelType, bool bIsSeamlessTravel)

APlayerController::BeginPlayingState
virtual ENGINE_API void BeginPlayingState()

APlayerController::SetAsLocalPlayerController
void SetAsLocalPlayerController()
Definition PlayerController.h:2245

APlayerController::GetNetworkPhysicsTickOffsetAssigned
bool GetNetworkPhysicsTickOffsetAssigned() const
Definition PlayerController.h:2322

APlayerController::UpdateHiddenComponents
virtual void UpdateHiddenComponents(const FVector &ViewLocation, TSet< FPrimitiveComponentId > &)
Definition PlayerController.h:1901

APlayerController::OnSerializeNewActor
virtual ENGINE_API void OnSerializeNewActor(class FOutBunch &OutBunch) override

APlayerController::SendClientAdjustment
virtual ENGINE_API void SendClientAdjustment()

APlayerController::GetClientHandshakeId
ENGINE_API uint32 GetClientHandshakeId() const

APlayerController::GetPhysicsTimestamp
FAsyncPhysicsTimestamp GetPhysicsTimestamp(float DeltaSeconds)
Definition PlayerController.h:2316

APlayerController::SetLocalPlayerConnectionIdentifier
ENGINE_API void SetLocalPlayerConnectionIdentifier(int32 Identifier)

APlayerController::ActiveHapticEffect_Left
TSharedPtr< struct FActiveHapticFeedbackEffect > ActiveHapticEffect_Left
Definition PlayerController.h:416

APlayerController::ActiveHapticEffect_Gun
TSharedPtr< struct FActiveHapticFeedbackEffect > ActiveHapticEffect_Gun
Definition PlayerController.h:418

APlayerController::OnReplicationStartedForIris
virtual ENGINE_API void OnReplicationStartedForIris(const FOnReplicationStartedParams &) override

APlayerController::GetAudioListenerAttenuationOverridePosition
virtual ENGINE_API bool GetAudioListenerAttenuationOverridePosition(FVector &OutLocation) const

APlayerController::ReceivedSpectatorClass
virtual ENGINE_API void ReceivedSpectatorClass(TSubclassOf< ASpectatorPawn > SpectatorClass)

APlayerController::ChangeState
virtual ENGINE_API void ChangeState(FName NewState) override

APlayerController::PendingMapChangeLevelNames
TArray< FName > PendingMapChangeLevelNames
Definition PlayerController.h:425

APlayerController::OnNetCleanup
virtual ENGINE_API void OnNetCleanup(class UNetConnection *Connection) override

APlayerController::ResetCameraMode
virtual ENGINE_API void ResetCameraMode()

APlayerController::OnPossess
virtual ENGINE_API void OnPossess(APawn *aPawn) override

APlayerController::GameHasEnded
virtual ENGINE_API void GameHasEnded(class AActor *EndGameFocus=nullptr, bool bIsWinner=false) override

APlayerController::InitInputSystem
virtual ENGINE_API void InitInputSystem()

APlayerController::bHidePawnInCinematicMode
uint32 bHidePawnInCinematicMode
Definition PlayerController.h:437

APlayerController::ForceFeedbackValues
FForceFeedbackValues ForceFeedbackValues
Definition PlayerController.h:422

APlayerController::IsFrozen
virtual ENGINE_API bool IsFrozen()

APlayerController::GetAudioListenerPosition
virtual ENGINE_API void GetAudioListenerPosition(FVector &OutLocation, FVector &OutFrontDir, FVector &OutRightDir) const

APlayerController::ShouldPerformFullTickWhenPaused
ENGINE_API bool ShouldPerformFullTickWhenPaused() const

APlayerController::PostInitializeComponents
virtual ENGINE_API void PostInitializeComponents() override

APlayerController::CurrentInputStack
TArray< TWeakObjectPtr< UInputComponent > > CurrentInputStack
Definition PlayerController.h:1695

APlayerController::CurrentClickablePrimitive
TWeakObjectPtr< UPrimitiveComponent > CurrentClickablePrimitive
Definition PlayerController.h:1689

APlayerController::SpawnPlayerCameraManager
virtual ENGINE_API void SpawnPlayerCameraManager()

APlayerController::EndPlayingState
virtual ENGINE_API void EndPlayingState()

APlayerController::GetPlayerViewPoint
virtual ENGINE_API void GetPlayerViewPoint(FVector &out_Location, FRotator &out_Rotation) const override

APlayerController::ReceivedPlayer
virtual ENGINE_API void ReceivedPlayer()

APlayerController::BuildHiddenComponentList
ENGINE_API void BuildHiddenComponentList(const FVector &ViewLocation, TSet< FPrimitiveComponentId > &HiddenComponentsOut)

APlayerController::UpdateHiddenActors
virtual void UpdateHiddenActors(const FVector &ViewLocation)
Definition PlayerController.h:1894

APlayerController::UpdateServerAsyncPhysicsTickOffset
ENGINE_API void UpdateServerAsyncPhysicsTickOffset()

APlayerController::SetCameraMode
virtual ENGINE_API void SetCameraMode(FName NewCamMode)

APlayerController::CleanupPlayerState
virtual ENGINE_API void CleanupPlayerState() override

APlayerController::bShortConnectTimeOut
uint32 bShortConnectTimeOut
Definition PlayerController.h:431

APlayerController::IsNetRelevantFor
virtual ENGINE_API bool IsNetRelevantFor(const AActor *RealViewer, const AActor *ViewTarget, const FVector &SrcLocation) const override

APlayerController::EndInactiveState
virtual ENGINE_API void EndInactiveState() override

APlayerController::ShouldParticipateInSeamlessTravel
virtual bool ShouldParticipateInSeamlessTravel() const override
Definition PlayerController.h:2251

APlayerController::TickActor
virtual ENGINE_API void TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction &ThisTickFunction) override

APlayerController::SetPawn
virtual ENGINE_API void SetPawn(APawn *InPawn) override

APlayerController::EndPlay
virtual ENGINE_API void EndPlay(const EEndPlayReason::Type EndPlayReason) override

APlayerController::EnableInput
virtual ENGINE_API void EnableInput(class APlayerController *PlayerController) override

APlayerController::FellOutOfWorld
virtual ENGINE_API void FellOutOfWorld(const class UDamageType &dmgType) override

APlayerController::CalcCamera
virtual ENGINE_API void CalcCamera(float DeltaTime, struct FMinimalViewInfo &OutResult) override

APlayerController::BeginInactiveState
virtual ENGINE_API void BeginInactiveState() override

APlayerController::bCinematicMode
uint32 bCinematicMode
Definition PlayerController.h:434

APlayerController::bIsUsingStreamingVolumes
uint32 bIsUsingStreamingVolumes
Definition PlayerController.h:440

APlayerController::OnUnPossess
virtual ENGINE_API void OnUnPossess() override

APlayerController::GetNetworkPhysicsTickOffset
int32 GetNetworkPhysicsTickOffset() const
Definition PlayerController.h:2319

APlayerController::GetLocalPlayerConnectionIdentifier
ENGINE_API int32 GetLocalPlayerConnectionIdentifier() const

APlayerState
Definition PlayerState.h:42

ASpectatorPawn
Definition SpectatorPawn.h:17

FArchive
Definition Archive.h:1208

FDebugDisplayInfo
Definition DisplayDebugHelpers.h:9

FInBunch
Definition DataBunch.h:127

FLifetimeProperty
Definition CoreNet.h:300

FName
Definition NameTypes.h:617

FObjectInitializer
Definition UObjectGlobals.h:1292

FObjectInitializer::Get
static COREUOBJECT_API FObjectInitializer & Get()
Definition UObjectGlobals.cpp:5001

FObjectProperty
Definition UnrealType.h:3087

FOutBunch
Definition DataBunch.h:24

FReply
Definition Reply.h:24

FText
Definition Text.h:385

FUniqueNetId
Definition CoreOnline.h:102

ICameraLensEffectInterface
Definition CameraLensEffectInterface.h:22

IInputInterface
Definition IInputInterface.h:309

SVirtualJoystick
Definition SVirtualJoystick.h:19

SWidget
Definition SWidget.h:165

TArray
Definition Array.h:670

TEnumAsByte
Definition EnumAsByte.h:22

TFunction
Definition AndroidPlatformMisc.h:14

TSharedPtr
Definition SharedPointer.h:692

TSharedRef
Definition SharedPointer.h:153

TSortedMap
Definition SortedMap.h:20

TSubclassOf
Definition SubclassOf.h:30

UActorChannel
Definition ActorChannel.h:78

UAsyncPhysicsInputComponent
Definition AsyncPhysicsInputComponent.h:11

UCameraShakeBase
Definition CameraShakeBase.h:440

UCameraShakeSourceComponent
Definition CameraShakeSourceComponent.h:41

UCanvas
Definition Canvas.h:159

UCheatManager
Definition CheatManager.h:99

UDamageType
Definition DamageType.h:21

UForceFeedbackEffect
Definition ForceFeedbackEffect.h:119

UGameViewportClient
Definition GameViewportClient.h:71

UHapticFeedbackEffect_Base
Definition HapticFeedbackEffect_Base.h:15

UInputComponent
Definition InputComponent.h:729

UInputSettings
Definition InputSettings.h:25

ULevelStreaming
Definition LevelStreaming.h:139

ULocalMessage
Definition LocalMessage.h:58

ULocalPlayer
Definition LocalPlayer.h:169

UMaterialInterface
Definition MaterialInterface.h:296

UNetConnection
Definition NetConnection.h:284

UObject
Definition Object.h:95

UPlayerInput
Definition PlayerInput.h:422

UPlayer
Definition Player.h:18

USoundBase
Definition SoundBase.h:109

UTouchInterface
Definition TouchInterface.h:60

UUserWidget
Definition UserWidget.h:284

Audio
NO_LOGGING.
Definition AudioMixerPlatformAndroid.cpp:53

EControllerAnalogStick
Definition InputComponent.h:680

EControllerAnalogStick::Type
Type
Definition InputComponent.h:682

EDynamicForceFeedbackAction
Definition PlayerController.h:68

EDynamicForceFeedbackAction::Type
Type
Definition PlayerController.h:70

EEndPlayReason::Type
Type
Definition EngineTypes.h:3431

EMouseCursor
Definition ICursor.h:16

ETouchIndex
Definition InputCoreTypes.h:255

ETouchType
Definition InputCoreTypes.h:773

TestServer.int
int
Definition TestServer.py:515

WorldPartition
Definition WorldPartition.cpp:74

false
@ false
Definition radaudio_common.h:23

AActor::FOnReplicationStartedParams
Definition Actor.h:3476

EKeys::NUM_TOUCH_KEYS
static const int32 NUM_TOUCH_KEYS
Definition InputCoreTypes.h:695

FActiveForceFeedbackEffect
Definition ForceFeedbackEffect.h:51

FActiveHapticFeedbackEffect
Definition HapticFeedbackEffect_Base.h:28

FActorTickFunction
Definition EngineBaseTypes.h:526

FAsyncPhysicsTimestamp
Definition PlayerController.h:231

FCollisionQueryParams
Definition CollisionQueryParams.h:43

FColor
Definition Color.h:486

FDateTime
Definition DateTime.h:76

FDynamicForceFeedbackDetails
Definition PlayerController.h:80

FDynamicForceFeedbackDetails::bAffectsRightLarge
uint32 bAffectsRightLarge
Definition PlayerController.h:83

FDynamicForceFeedbackDetails::Update
void Update(FForceFeedbackValues &Values) const

FDynamicForceFeedbackDetails::Intensity
float Intensity
Definition PlayerController.h:86

FDynamicForceFeedbackDetails::FDynamicForceFeedbackDetails
FDynamicForceFeedbackDetails()
Definition PlayerController.h:88

FDynamicForceFeedbackDetails::bAffectsLeftLarge
uint32 bAffectsLeftLarge
Definition PlayerController.h:81

FDynamicForceFeedbackDetails::bAffectsRightSmall
uint32 bAffectsRightSmall
Definition PlayerController.h:84

FDynamicForceFeedbackDetails::bAffectsLeftSmall
uint32 bAffectsLeftSmall
Definition PlayerController.h:82

FForceFeedbackEffectHistoryEntry
Definition PlayerController.cpp:179

FForceFeedbackParameters
Definition ForceFeedbackParameters.h:9

FForceFeedbackValues
Definition IInputInterface.h:26

FGuid
Definition Guid.h:109

FHitResult
Definition HitResult.h:21

FInputDeviceId
Definition CoreMiscDefines.h:524

FInputKeyEventArgs
Definition InputKeyEventArgs.h:26

FInputModeDataBase
Definition PlayerController.h:101

FInputModeDataBase::ApplyInputMode
virtual void ApplyInputMode(class FReply &SlateOperations, class UGameViewportClient &GameViewportClient) const =0

FInputModeDataBase::SetFocusAndLocking
ENGINE_API void SetFocusAndLocking(FReply &SlateOperations, TSharedPtr< class SWidget > InWidgetToFocus, bool bLockMouseToViewport, TSharedRef< class SViewport > InViewportWidget) const

FInputModeDataBase::~FInputModeDataBase
virtual ~FInputModeDataBase()
Definition PlayerController.h:103

FInputModeDataBase::ShouldFlushInputOnViewportFocus
virtual bool ShouldFlushInputOnViewportFocus() const
Definition PlayerController.h:108

FInputModeGameAndUI
Definition PlayerController.h:180

FInputModeGameAndUI::SetHideCursorDuringCapture
FInputModeGameAndUI & SetHideCursorDuringCapture(bool InHideCursorDuringCapture)
Definition PlayerController.h:192

FInputModeGameAndUI::SetLockMouseToViewportBehavior
FInputModeGameAndUI & SetLockMouseToViewportBehavior(EMouseLockMode InMouseLockMode)
Definition PlayerController.h:189

FInputModeGameAndUI::WidgetToFocus
TSharedPtr< SWidget > WidgetToFocus
Definition PlayerController.h:202

FInputModeGameAndUI::FInputModeGameAndUI
ENGINE_API FInputModeGameAndUI()

FInputModeGameAndUI::ApplyInputMode
virtual ENGINE_API void ApplyInputMode(FReply &SlateOperations, class UGameViewportClient &GameViewportClient) const override

FInputModeGameAndUI::MouseLockMode
EMouseLockMode MouseLockMode
Definition PlayerController.h:203

FInputModeGameAndUI::ShouldFlushInputOnViewportFocus
virtual bool ShouldFlushInputOnViewportFocus() const override
Definition PlayerController.h:194

FInputModeGameAndUI::SetWidgetToFocus
FInputModeGameAndUI & SetWidgetToFocus(TSharedPtr< SWidget > InWidgetToFocus)
Definition PlayerController.h:186

FInputModeGameAndUI::bHideCursorDuringCapture
bool bHideCursorDuringCapture
Definition PlayerController.h:204

FInputModeGameAndUI::~FInputModeGameAndUI
virtual ENGINE_API ~FInputModeGameAndUI()

FInputModeGameOnly
Definition PlayerController.h:211

FInputModeGameOnly::SetConsumeCaptureMouseDown
FInputModeGameOnly & SetConsumeCaptureMouseDown(bool InConsumeCaptureMouseDown)
Definition PlayerController.h:217

FInputModeGameOnly::FInputModeGameOnly
ENGINE_API FInputModeGameOnly()

FInputModeGameOnly::~FInputModeGameOnly
virtual ENGINE_API ~FInputModeGameOnly()

FInputModeGameOnly::bConsumeCaptureMouseDown
bool bConsumeCaptureMouseDown
Definition PlayerController.h:224

FInputModeGameOnly::ApplyInputMode
virtual ENGINE_API void ApplyInputMode(FReply &SlateOperations, class UGameViewportClient &GameViewportClient) const override

FInputModeUIOnly
Definition PlayerController.h:125

FInputModeUIOnly::ApplyInputMode
virtual ENGINE_API void ApplyInputMode(FReply &SlateOperations, class UGameViewportClient &GameViewportClient) const override

FInputModeUIOnly::SetLockMouseToViewportBehavior
ENGINE_API FInputModeUIOnly & SetLockMouseToViewportBehavior(EMouseLockMode InMouseLockMode)

FInputModeUIOnly::MouseLockMode
EMouseLockMode MouseLockMode
Definition PlayerController.h:142

FInputModeUIOnly::SetWidgetToFocus
ENGINE_API FInputModeUIOnly & SetWidgetToFocus(TSharedPtr< SWidget > InWidgetToFocus)

FInputModeUIOnly::~FInputModeUIOnly
virtual ENGINE_API ~FInputModeUIOnly()

FInputModeUIOnly::FInputModeUIOnly
ENGINE_API FInputModeUIOnly()

FInputModeUIOnly::WidgetToFocus
TSharedPtr< SWidget > WidgetToFocus
Definition PlayerController.h:141

FKey
Definition InputCoreTypes.h:50

FLatentActionInfo
Definition LatentActionManager.h:19

FMinimalViewInfo
Definition CameraTypes.h:37

FNetLevelVisibilityTransactionId
Definition UpdateLevelVisibilityLevelInfo.h:10

FPlatformUserId
Definition CoreMiscDefines.h:470

FPlayerMuteList
Definition PlayerMuteList.h:30

FStreamingSourceShape
Definition WorldPartitionStreamingSource.h:95

FTimerHandle
Definition TimerHandle.h:12

FUObjectMigrationContext
Definition UObjectMigrationContext.h:62

FUniqueNetIdRepl
Definition OnlineReplStructs.h:26

FUpdateLevelStreamingLevelStatus
Definition PlayerController.h:150

FUpdateLevelStreamingLevelStatus::GENERATED_BODY
GENERATED_BODY()

FUpdateLevelVisibilityLevelInfo
Definition UpdateLevelVisibilityLevelInfo.h:52

FVector_NetQuantize
Definition NetSerialization.h:410

FViewTargetTransitionParams
Definition PlayerCameraManager.h:117

FWorldPartitionStreamingSource
Definition WorldPartitionStreamingSource.h:344

IWorldPartitionStreamingSourceProvider
Definition WorldPartitionStreamingSource.h:546

TObjectPtr
Definition ObjectPtr.h:488

TWeakObjectPtr
Definition WeakObjectPtrTemplates.h:25

UE::Math::TRotator< double >

UE::Math::TVector2< double >

UE::Math::TVector< double >