GameViewportClient.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Delegates/IDelegateInstance.h"
#include "UObject/ObjectMacros.h"
#include "InputCoreTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "UObject/ScriptMacros.h"
#include "Input/PopupMethodReply.h"
//#include "Widgets/SWidget.h"
//#include "Widgets/SOverlay.h"
#include "ShowFlags.h"
#include "Engine/ScriptViewportClient.h"
#include "Engine/ViewportSplitScreen.h"
#include "Engine/TitleSafeZone.h"
#include "Engine/GameViewportDelegates.h"
#include "Engine/DebugDisplayProperty.h"
#include "UObject/SoftObjectPath.h"
#include "StereoRendering.h"
#include "AudioDeviceHandle.h"
 
#include "GameViewportClient.generated.h"
 
class FCanvas;
class FSceneView;
class FSceneViewport;
class FViewportFrame;
class IGameLayerManager;
class SOverlay;
class SViewport;
class SWidget;
class SWindow;
class UCanvas;
class UGameInstance;
class ULocalPlayer;
class UNetDriver;
struct FMargin;
 
enum class EViewStatusForScreenPercentage;
 
DECLARE_DELEGATE_RetVal_TwoParams(bool, FCustomNavigationHandler, const uint32, TSharedPtr<SWidget>);
 
DECLARE_DELEGATE_RetVal_OneParam(bool, FOverrideInputKeyHandler, FInputKeyEventArgs& /*EventArgs*/);
 
DECLARE_DELEGATE_RetVal_FourParams(bool, FOverrideInputAxisHandler, FInputKeyEventArgs& /*EventArgs*/, float& /*Delta*/, float& /*DeltaTime*/, int32& /*NumSamples*/);
 
DECLARE_MULTICAST_DELEGATE_SevenParams(FOnInputAxisSignature, FViewport* /*InViewport*/, int32 /*ControllerId*/, FKey /*Key*/, float /*Delta*/, float /*DeltaTime*/, int32 /*NumSamples*/, bool /*bGamepad*/);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnInputKeySignature, const FInputKeyEventArgs& /*EventArgs*/);
 
UCLASS(Within=Engine, transient, config=Engine, MinimalAPI)
class UGameViewportClient : public UScriptViewportClient, public FExec
{
    GENERATED_UCLASS_BODY()
 
public:
    ENGINE_API UGameViewportClient(FVTableHelper& Helper);
 
    ENGINE_API virtual ~UGameViewportClient();
 
    UPROPERTY()
    TObjectPtr<class UConsole> ViewportConsole;
 
    UPROPERTY()
    TArray<struct FDebugDisplayProperty> DebugProperties;
 
    TArray<struct FSplitscreenData> SplitscreenInfo;
 
    UPROPERTY(Config)
    int32 MaxSplitscreenPlayers = 4;
 
    uint32 bIsPlayInEditorViewport:1;
 
    uint32 bDisableWorldRendering:1;
 
protected:
    TEnumAsByte<ESplitScreenType::Type> ActiveSplitscreenType;
 
    /* The relative world context for this viewport */
    UPROPERTY()
    TObjectPtr<UWorld> World;
 
    UPROPERTY()
    TObjectPtr<UGameInstance> GameInstance;
 
    bool bSuppressTransitionMessage;
 
    FAudioDeviceHandle AudioDevice;
 
    FDelegateHandle AudioDeviceDestroyedHandle;
 
public:
 
    int32 ViewModeIndex;
 
    UFUNCTION(exec)
    ENGINE_API virtual void SSSwapControllers();
 
    UFUNCTION(exec, meta = (DeprecatedFunction, DeprecationMessage = "Use the cvar \"r.DebugSafeZone.Mode=1.\""))
    ENGINE_API virtual void ShowTitleSafeArea();
 
    UFUNCTION(exec)
    ENGINE_API virtual void SetConsoleTarget(int32 PlayerIndex);
 
    UE_DEPRECATED(5.4, "AddCursorWidget is deprecated, use SetSoftwareCursorWidget instead.")
    ENGINE_API void AddCursorWidget(EMouseCursor::Type Cursor, class UUserWidget* CursorWidget);
 
    ENGINE_API virtual UWorld* GetWorld() const override;
 
    /* Create the game viewport */
    ENGINE_API virtual FSceneViewport* CreateGameViewport(TSharedPtr<SViewport> InViewportWidget);
 
    /* Returns the game viewport */
    ENGINE_API FSceneViewport* GetGameViewport();
    ENGINE_API const FSceneViewport* GetGameViewport() const;
 
    /* Returns the widget for this viewport */
    ENGINE_API TSharedPtr<SViewport> GetGameViewportWidget() const;
 
    /* Returns the relevant game instance for this viewport */
    ENGINE_API UGameInstance* GetGameInstance() const;
 
    ENGINE_API virtual void Init(struct FWorldContext& WorldContext, UGameInstance* OwningGameInstance, bool bCreateNewAudioDevice = true);
 
public:
    //~ Begin UObject Interface
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void BeginDestroy() override;
    //~ End UObject Interface
 
    //~ Begin FViewportClient Interface.
    virtual void RedrawRequested(FViewport* InViewport) override {}
    ENGINE_API virtual bool InputKey(const FInputKeyEventArgs& EventArgs) override;
    ENGINE_API virtual bool InputAxis(const FInputKeyEventArgs& EventArgs) override;
    ENGINE_API virtual bool InputChar(FViewport* Viewport,int32 ControllerId, TCHAR Character) override;
    ENGINE_API virtual bool InputTouch(FViewport* InViewport, const FInputDeviceId DeviceId, uint32 Handle, ETouchType::Type Type, const FVector2D& TouchLocation, float Force, uint32 TouchpadIndex, const uint64 Timestamp) override;
    ENGINE_API virtual bool InputMotion(FViewport* Viewport, const FInputDeviceId DeviceId, const FVector& Tilt, const FVector& RotationRate, const FVector& Gravity, const FVector& Acceleration, const uint64 Timestamp) override;
    ENGINE_API virtual EMouseCursor::Type GetCursor(FViewport* Viewport, int32 X, int32 Y ) override;
    ENGINE_API virtual TOptional<TSharedRef<SWidget>> MapCursor(FViewport* Viewport, const FCursorReply& CursorReply) override;
    ENGINE_API virtual void Precache() override;
    ENGINE_API virtual void Draw(FViewport* Viewport,FCanvas* SceneCanvas) override;
    ENGINE_API virtual bool ProcessScreenShots(FViewport* Viewport) override;
    ENGINE_API virtual TOptional<bool> QueryShowFocus(const EFocusCause InFocusCause) const override;
    ENGINE_API virtual void LostFocus(FViewport* Viewport) override;
    ENGINE_API virtual void ReceivedFocus(FViewport* Viewport) override;
    ENGINE_API virtual bool IsFocused(FViewport* Viewport) override;
    ENGINE_API virtual void Activated(FViewport* InViewport, const FWindowActivateEvent& InActivateEvent) override;
    ENGINE_API virtual void Deactivated(FViewport* InViewport, const FWindowActivateEvent& InActivateEvent) override;
    ENGINE_API virtual bool IsInPermanentCapture() override;
    ENGINE_API virtual bool WindowCloseRequested() override;
    ENGINE_API virtual void CloseRequested(FViewport* Viewport) override;
    virtual bool RequiresHitProxyStorage() override { return 0; }
    ENGINE_API virtual bool IsOrtho() const override;
    ENGINE_API virtual void MouseEnter(FViewport* Viewport, int32 x, int32 y) override;
    ENGINE_API virtual void MouseLeave(FViewport* Viewport) override;
    ENGINE_API virtual void SetIsSimulateInEditorViewport(bool bInIsSimulateInEditorViewport) override;
 
    //~ End FViewportClient Interface.
 
    virtual void FinalizeViews(class FSceneViewFamily* ViewFamily, const TMap<ULocalPlayer*, FSceneView*>& PlayerViewMap)
    {}
 
    //~ Begin FExec Interface.
#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_Runtime( UWorld* InWorld, const TCHAR* Cmd,FOutputDevice& Ar) override;
    //~ End FExec Interface.
 
public:
    ENGINE_API bool TryToggleFullscreenOnInputKey(FKey Key, EInputEvent EventType);
 
    ENGINE_API virtual void RemapControllerInput(FInputKeyEventArgs& InOutKeyEvent);
 
    ENGINE_API bool HandleForceFullscreenCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleShowCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleShowLayerCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleViewModeCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleNextViewModeCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandlePrevViewModeCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandlePreCacheCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleFullscreenCommand();
    ENGINE_API bool HandleSetResCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleHighresScreenshotCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleHighresScreenshotUICommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleScreenshotCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleBugScreenshotwithHUDInfoCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleBugScreenshotCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleKillParticlesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleForceSkelLODCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleDisplayCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDisplayAllCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDisplayAllLocationCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDisplayAllRotationCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDisplayClearCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleGetAllLocationCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleGetAllRotationCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleTextureDefragCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleMIPFadeCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandlePauseRenderClockCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    ENGINE_API virtual void AddViewportWidgetContent( TSharedRef<class SWidget> ViewportContent, const int32 ZOrder = 0 );
 
    ENGINE_API virtual void RemoveViewportWidgetContent( TSharedRef<class SWidget> ViewportContent );
 
    ENGINE_API virtual void AddViewportWidgetForPlayer(ULocalPlayer* Player, TSharedRef<SWidget> ViewportContent, const int32 ZOrder);
 
    ENGINE_API virtual void RemoveViewportWidgetForPlayer(ULocalPlayer* Player, TSharedRef<SWidget> ViewportContent);
 
    ENGINE_API void RemoveAllViewportWidgets();
 
    ENGINE_API virtual void AddGameLayerWidget(TSharedRef<SWidget> ViewportContent, const int32 ZOrder);
 
    ENGINE_API virtual void RemoveGameLayerWidget(TSharedRef<SWidget> ViewportContent);
 
    ENGINE_API void RebuildCursors();
 
    ENGINE_API virtual void DetachViewportClient();
 
    ENGINE_API virtual void Tick( float DeltaTime );
 
    ENGINE_API virtual bool RequiresUncapturedAxisInput() const override;
 
    ENGINE_API virtual void SetViewportFrame( FViewportFrame* InViewportFrame );
 
    ENGINE_API virtual void SetViewport( FViewport* InViewportFrame );
 
    ENGINE_API void SetViewportOverlayWidget(TSharedPtr< SWindow > InWindow, TSharedRef<SOverlay> InViewportOverlayWidget);
 
    ENGINE_API void SetGameLayerManager(TSharedPtr< IGameLayerManager > LayerManager);
 
    TSharedPtr< IGameLayerManager > GetGameLayerManager() const
    {
        return GameLayerManagerPtr.Pin();
    }
 
    TSharedPtr< SWindow > GetWindow()
    {
         return Window.Pin();
    }
    
    ENGINE_API virtual void SetDropDetail(float DeltaSeconds);
 
    ENGINE_API virtual FString ConsoleCommand( const FString& Command );
 
    ENGINE_API void GetViewportSize( FVector2D& ViewportSize ) const;
 
    ENGINE_API bool IsFullScreenViewport() const;
 
    ENGINE_API bool IsExclusiveFullscreenViewport() const;
 
    ENGINE_API virtual bool GetMousePosition(FVector2D& MousePosition) const;
 
    ENGINE_API bool ShouldForceFullscreenViewport() const;
 
    ENGINE_API virtual ULocalPlayer* SetupInitialLocalPlayer(FString& OutError);
 
    inline ESplitScreenType::Type GetCurrentSplitscreenConfiguration() const
    {
        return ActiveSplitscreenType;
    }
 
    ENGINE_API virtual void UpdateActiveSplitscreenType();
 
    ENGINE_API virtual void LayoutPlayers();
 
    ENGINE_API void SetForceDisableSplitscreen(const bool bDisabled);
 
    bool IsSplitscreenForceDisabled() const
    {
        return bDisableSplitScreenOverride;
    }
 
    ENGINE_API virtual void GetSubtitleRegion(FVector2D& MinPos, FVector2D& MaxPos);
 
    ENGINE_API int32 ConvertLocalPlayerToGamePlayerIndex( ULocalPlayer* LPlayer );
 
    ENGINE_API bool HasTopSafeZone( int32 LocalPlayerIndex );
 
    ENGINE_API bool HasBottomSafeZone( int32 LocalPlayerIndex );
 
    ENGINE_API bool HasLeftSafeZone( int32 LocalPlayerIndex );
 
    ENGINE_API bool HasRightSafeZone( int32 LocalPlayerIndex );
 
    ENGINE_API void GetPixelSizeOfScreen( float& Width, float& Height, UCanvas* Canvas, int32 LocalPlayerIndex );
 
    ENGINE_API void CalculateSafeZoneValues( FMargin& SafeZone, UCanvas* Canvas, int32 LocalPlayerIndex, bool bUseMaxPercent );
 
    ENGINE_API bool CalculateDeadZoneForAllSides( ULocalPlayer* LPlayer, UCanvas* Canvas, float& fTopSafeZone, float& fBottomSafeZone, float& fLeftSafeZone, float& fRightSafeZone, bool bUseMaxPercent = false );
 
    ENGINE_API virtual void DrawTitleSafeArea( UCanvas* Canvas );
 
    ENGINE_API virtual void PostRender( UCanvas* Canvas );
 
    ENGINE_API virtual void DrawTransition( UCanvas* Canvas );
 
    ENGINE_API virtual void DrawTransitionMessage( UCanvas* Canvas, const FString& Message );
 
    ENGINE_API virtual void NotifyPlayerAdded( int32 PlayerIndex, class ULocalPlayer* AddedPlayer );
 
    ENGINE_API virtual void NotifyPlayerRemoved( int32 PlayerIndex, class ULocalPlayer* RemovedPlayer );
 
    ENGINE_API virtual void PeekTravelFailureMessages(UWorld* InWorld, enum ETravelFailure::Type FailureType, const FString& ErrorString);
 
    ENGINE_API virtual void PeekNetworkFailureMessages(UWorld *InWorld, UNetDriver *NetDriver, enum ENetworkFailure::Type FailureType, const FString& ErrorString);
 
    ENGINE_API virtual void VerifyPathRenderingComponents();
 
    static FOnScreenshotCaptured& OnScreenshotCaptured()
    {
        return ScreenshotCapturedDelegate;
    }
    
    static FOnViewportRendered& OnViewportRendered()
    {
        return ViewportRenderedDelegate;
    }
    
    /* Accessor for the delegate called when a viewport is asked to close. */
    FOnCloseRequested& OnCloseRequested()
    {
        return CloseRequestedDelegate;
    }
 
    FOnWindowCloseRequested& OnWindowCloseRequested()
    {
        return WindowCloseRequestedDelegate;
    }
 
    static FSimpleMulticastDelegate& OnViewportCreated()
    {
        return CreatedDelegate;
    }
 
    // Accessor for the delegate called when a player is added to the game viewport
    FOnGameViewportClientPlayerAction& OnPlayerAdded()
    {
        return PlayerAddedDelegate;
    }
 
    // Accessor for the delegate called when a player is removed from the game viewport
    FOnGameViewportClientPlayerAction& OnPlayerRemoved()
    {
        return PlayerRemovedDelegate;
    }
 
    // Accessor for the delegate called when the engine starts drawing a game viewport
    FSimpleMulticastDelegate& OnBeginDraw()
    {
        return BeginDrawDelegate;
    }
 
    // Accessor for the delegate called when the game viewport is drawn, before drawing the console
    FSimpleMulticastDelegate& OnDrawn()
    {
        return DrawnDelegate;
    }
 
    // Accessor for the delegate called when the engine finishes drawing a game viewport
    FSimpleMulticastDelegate& OnEndDraw()
    {
        return EndDrawDelegate;
    }
 
    // Accessor for the delegate called when ticking the game viewport
    FOnGameViewportTick& OnTick()
    {
        return TickDelegate;
    }
 
    FCustomNavigationHandler& OnNavigationOverride()
    {
        return CustomNavigationEvent;
    }
 
    FOverrideInputKeyHandler& OnOverrideInputKey()
    {
        return OnOverrideInputKeyEvent;
    }
 
    FOverrideInputAxisHandler& OnOverrideInputAxis()
    {
        return OnOverrideInputAxisEvent;
    }
 
    FOnInputKeySignature& OnInputKey()
    {
        return OnInputKeyEvent;
    }
 
    FOnInputAxisSignature& OnInputAxis()
    {
        return OnInputAxisEvent;
    }
 
    virtual FEngineShowFlags* GetEngineShowFlags() override
    { 
        return &EngineShowFlags; 
    }
    
    ENGINE_API void SetViewMode(EViewModeIndex ViewMode, FOutputDevice* Output = nullptr);
 
    ENGINE_API bool SetHardwareCursor(EMouseCursor::Type CursorShape, FName GameContentPath, FVector2D HotSpot);
 
    ENGINE_API bool IsSimulateInEditorViewport() const;
 
    virtual bool ShouldDPIScaleSceneCanvas() const override { return false; }
 
    ENGINE_API bool GetUseMouseForTouch() const;
 
    void SetCurrentBufferVisualizationMode(FName NewBufferVisualizationMode) { CurrentBufferVisualizationMode = NewBufferVisualizationMode; }
    FName GetCurrentBufferVisualizationMode() const { return CurrentBufferVisualizationMode; }
 
    void SetCurrentNaniteVisualizationMode(FName NewNaniteVisualizationMode) { CurrentNaniteVisualizationMode = NewNaniteVisualizationMode; }
    FName GetCurrentNaniteVisualizationMode() const { return CurrentNaniteVisualizationMode; }
 
    void SetCurrentLumenVisualizationMode(FName NewLumenVisualizationMode) { CurrentLumenVisualizationMode = NewLumenVisualizationMode; }
    FName GetCurrentLumenVisualizationMode() const { return CurrentLumenVisualizationMode; }
 
    void SetCurrentSubstrateVisualizationMode(FName NewSubstrateVisualizationMode) { CurrentSubstrateVisualizationMode = NewSubstrateVisualizationMode; }
    FName GetCurrentSubstrateVisualizationMode() const { return CurrentSubstrateVisualizationMode; }
 
    void SetCurrentGroomVisualizationMode(FName NewGroomVisualizationMode) { CurrentGroomVisualizationMode = NewGroomVisualizationMode; }
    FName GetCurrentGroomVisualizationMode() const { return CurrentGroomVisualizationMode; }
 
    void SetCurrentVirtualShadowMapVisualizationMode(FName NewVirtualShadowMapVisualizationMode) { CurrentVirtualShadowMapVisualizationMode = NewVirtualShadowMapVisualizationMode; }
    FName GetCurrentVirtualShadowMapVisualizationMode() const { return CurrentVirtualShadowMapVisualizationMode; }
 
protected:
    bool HasAudioFocus() const { return bHasAudioFocus; }
 
    ENGINE_API void UpdateCsvCameraStats(const TMap<ULocalPlayer*, FSceneView*>& PlayerViewMap);
 
protected:
    ENGINE_API virtual float UpdateViewportClientWindowDPIScale() const override;
 
public:
    FEngineShowFlags EngineShowFlags;
 
    FViewport* Viewport;
 
    FViewportFrame* ViewportFrame;
 
    void SetSuppressTransitionMessage( bool bSuppress )
    {
        bSuppressTransitionMessage = bSuppress;
    }
 
    virtual FStatUnitData* GetStatUnitData() const override
    {
        return StatUnitData;
    }
 
    virtual FStatHitchesData* GetStatHitchesData() const override
    {
        return StatHitchesData;
    }
 
    virtual const TArray<FString>* GetEnabledStats() const override
    {
        return &EnabledStats;
    }
 
    ENGINE_API virtual void SetEnabledStats(const TArray<FString>& InEnabledStats) override;
 
    virtual bool IsStatEnabled(const FString& InName) const override
    {
        return EnabledStats.Contains(InName);
    }
 
    void SetIgnoreInput(bool Ignore)
    {
        bIgnoreInput = Ignore;
    }
 
    virtual bool IgnoreInput() override
    {
        return bIgnoreInput;
    }
 
    ENGINE_API void SetMouseCaptureMode(EMouseCaptureMode Mode);
 
    ENGINE_API virtual EMouseCaptureMode GetMouseCaptureMode() const override;
 
    ENGINE_API virtual bool CaptureMouseOnLaunch() override;
 
    virtual bool LockDuringCapture() override
    {
        return MouseLockMode != EMouseLockMode::DoNotLock;
    }
 
    virtual bool ShouldAlwaysLockMouse() override
    {
        return MouseLockMode == EMouseLockMode::LockAlways
             || (MouseLockMode == EMouseLockMode::LockInFullscreen && IsExclusiveFullscreenViewport());
    }
 
    ENGINE_API void SetMouseLockMode(EMouseLockMode InMouseLockMode);
 
    ENGINE_API EMouseLockMode GetMouseLockMode() const;
 
    ENGINE_API void SetHideCursorDuringCapture(bool InHideCursorDuringCapture);
 
    virtual bool HideCursorDuringCapture() const override
    {
        return bHideCursorDuringCapture;
    }
 
    ENGINE_API virtual FPopupMethodReply OnQueryPopupMethod() const override;
 
    ENGINE_API virtual bool HandleNavigation(const uint32 InUserIndex, TSharedPtr<SWidget> InDestination) override;
 
    void SetUseSoftwareCursorWidgets(bool bInUseSoftwareCursorWidgets)
    {
        bUseSoftwareCursorWidgets = bInUseSoftwareCursorWidgets;
    }
 
    bool GetIsUsingSoftwareCursorWidgets() { return bUseSoftwareCursorWidgets; }
 
#if WITH_EDITOR
    FOnGameViewportInputKey& OnGameViewportInputKey()
    {
        return GameViewportInputKeyDelegate;
    }
#endif
 
    FOnToggleFullscreen& OnToggleFullscreen()
    {
        return ToggleFullscreenDelegate;
    }
 
    ENGINE_API bool SetDisplayConfiguration( const FIntPoint* Dimensions, EWindowMode::Type WindowMode);
 
    UE_DEPRECATED(5.4, "SetVirtualCursorWidget is deprecated, use SetSoftwareCursorWidget instead.")
    ENGINE_API void SetVirtualCursorWidget(EMouseCursor::Type Cursor, class UUserWidget* Widget);
 
    UE_DEPRECATED(5.4, "AddSoftwareCursorFromSlateWidget is deprecated, use SetSoftwareCursorWidget instead.")
    ENGINE_API void AddSoftwareCursorFromSlateWidget(EMouseCursor::Type InCursorType, TSharedPtr<SWidget> CursorWidgetPtr);
 
    UE_DEPRECATED(5.4, "AddSoftwareCursor is deprecated, use SetSoftwareCursorWidget instead and pass the Created Widget instead of the UserWidget Class.")
    ENGINE_API void AddSoftwareCursor(EMouseCursor::Type Cursor, const FSoftClassPath& CursorClass);
 
    ENGINE_API void SetSoftwareCursorWidget(EMouseCursor::Type InCursorType, class UUserWidget* Widget);
 
    ENGINE_API void SetSoftwareCursorWidget(EMouseCursor::Type InCursorType, TSharedPtr<SWidget> CursorWidgetPtr);
 
    ENGINE_API TSharedPtr<SWidget> GetSoftwareCursorWidget(EMouseCursor::Type Cursor) const;
 
    ENGINE_API bool HasSoftwareCursor(EMouseCursor::Type Cursor) const;
 
    ENGINE_API void EnableCsvPlayerStats(int32 LocalPlayerCount);
 
    ENGINE_API EViewStatusForScreenPercentage GetViewStatusForScreenPercentage() const;
 
private:
    ENGINE_API void ResetHardwareCursorStates();
 
    void SetSoftwareCursorFromClassPath(EMouseCursor::Type Cursor, const FSoftClassPath& CursorClass);
 
    int32 SetStatEnabled(const TCHAR* InName, const bool bEnable, const bool bAll = false)
    {
        if (bEnable)
        {
            check(!bAll);   // Not possible to enable all
            EnabledStats.AddUnique(InName);
        }
        else
        {
            if (bAll)
            {
                EnabledStats.Empty();
            }
            else
            {
                EnabledStats.Remove(InName);
            }
        }
        return EnabledStats.Num();
    }
 
    ENGINE_API void ToggleShowVolumes();
 
    ENGINE_API void ToggleShowCollision();
 
    ENGINE_API void HandleViewportStatCheckEnabled(const TCHAR* InName, bool& bOutCurrentEnabled, bool& bOutOthersEnabled);
 
    ENGINE_API void HandleViewportStatEnabled(const TCHAR* InName);
 
    ENGINE_API void HandleViewportStatDisabled(const TCHAR* InName);
 
    ENGINE_API void HandleViewportStatDisableAll(const bool bInAnyViewport);
 
    ENGINE_API void HandleWindowDPIScaleChanged(TSharedRef<SWindow> InWindow);
 
    struct FPngFileData
    {
        FString FileName;
        double ScaleFactor;
        TArray<uint8> FileData;
 
        FPngFileData()
            : ScaleFactor(1.0)
        {
        }
    };
 
    ENGINE_API void* LoadCursorFromPngs(ICursor& PlatformCursor, const FString& InPathToCursorWithoutExtension, FVector2D InHotSpot);
 
    ENGINE_API bool LoadAvailableCursorPngs(TArray<TSharedPtr<FPngFileData>>& Results, const FString& InPathToCursorWithoutExtension);
 
    ENGINE_API void AddDebugDisplayProperty(class UObject* Obj, TSubclassOf<class UObject> WithinClass, const FName& PropertyName, bool bSpecialProperty = false);
 
protected:
    uint32 AudioDeviceHandle = uint32(INDEX_NONE);
 
    bool bHasAudioFocus = false;
 
private:
    TWeakPtr<SWindow> Window;
 
    TWeakPtr<SOverlay> ViewportOverlayWidget;
 
    TWeakPtr<IGameLayerManager> GameLayerManagerPtr;
 
    FName CurrentBufferVisualizationMode;
 
    FName CurrentNaniteVisualizationMode;
 
    FName CurrentLumenVisualizationMode;
 
    FName CurrentSubstrateVisualizationMode;
 
    FName CurrentGroomVisualizationMode;
 
    FName CurrentVirtualShadowMapVisualizationMode;
 
    TWeakPtr<SWindow> HighResScreenshotDialog;
 
    TMap<FName, void*> HardwareCursorCache;
 
    TMap<EMouseCursor::Type, void*> HardwareCursors;
 
    TMap<EMouseCursor::Type, TSharedPtr<SWidget>> CursorWidgets;
 
    bool bUseSoftwareCursorWidgets;
 
    /* Function that handles bug screen-shot requests w/ or w/o extra HUD info (project-specific) */
    ENGINE_API bool RequestBugScreenShot(const TCHAR* Cmd, bool bDisplayHUDInfo);
 
#if WITH_EDITOR
    FOnGameViewportInputKey GameViewportInputKeyDelegate;
#endif
 
    static ENGINE_API FOnScreenshotCaptured ScreenshotCapturedDelegate;
    
    static ENGINE_API FOnViewportRendered ViewportRenderedDelegate;
 
    FOnCloseRequested CloseRequestedDelegate;
 
    FOnWindowCloseRequested WindowCloseRequestedDelegate;
 
    static ENGINE_API FSimpleMulticastDelegate CreatedDelegate;
 
    FOnGameViewportClientPlayerAction PlayerAddedDelegate;
 
    FOnGameViewportClientPlayerAction PlayerRemovedDelegate;
 
    FSimpleMulticastDelegate BeginDrawDelegate;
 
    FSimpleMulticastDelegate DrawnDelegate;
 
    FSimpleMulticastDelegate EndDrawDelegate;
 
    FOnGameViewportTick TickDelegate;
 
    FOnToggleFullscreen ToggleFullscreenDelegate;
 
    FCustomNavigationHandler CustomNavigationEvent;
 
    FOverrideInputKeyHandler OnOverrideInputKeyEvent;
 
    FOverrideInputAxisHandler OnOverrideInputAxisEvent;
 
    FOnInputKeySignature OnInputKeyEvent;
 
    FOnInputAxisSignature OnInputAxisEvent;
 
    FStatUnitData* StatUnitData;
 
    FStatHitchesData* StatHitchesData;
 
    static ENGINE_API TArray<FString> EnabledStats;
 
    bool bDisableSplitScreenOverride;
 
    bool bIgnoreInput;
 
    EMouseCaptureMode MouseCaptureMode;
 
    bool bHideCursorDuringCapture;
 
    EMouseLockMode MouseLockMode;
 
    bool bIsMouseOverClient;
 
#if WITH_EDITOR
    bool bUseMouseForTouchInEditor;
#endif
};