UnrealClient.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UnrealClient.h: Interface definition for platform specific client code.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "InputKeyEventArgs.h"
#include "Engine/EngineBaseTypes.h"
#include "UObject/GCObject.h"
#include "RenderResource.h"
#include "HitProxies.h"
#include "RenderGraphDefinitions.h"
#include "Elements/Framework/TypedElementListFwd.h"
#include "GenericPlatform/GenericWindow.h"
#include "DynamicRenderScaling.h"
 
class FCanvas;
class FRDGBuilder;
class FViewport;
class FViewportClient;
class UModel;
 
class FRenderTarget
{
public:
 
    ENGINE_API FRenderTarget();
 
    ENGINE_API virtual ~FRenderTarget();
 
    ENGINE_API virtual const FTextureRHIRef& GetRenderTargetTexture() const;
    ENGINE_API virtual FUnorderedAccessViewRHIRef GetRenderTargetUAV() const;
 
    ENGINE_API virtual FRDGTextureRef GetRenderTargetTexture(FRDGBuilder& GraphBuilder) const;
 
    ENGINE_API virtual const FTextureRHIRef& GetShaderResourceTexture() const;
 
    // Properties.
    virtual FIntPoint GetSizeXY() const = 0;
 
    ENGINE_API virtual float GetDisplayGamma() const;
 
    // return global Engine default gamma (GetDisplayGamma returns this if not overriden)
    static float GetEngineDisplayGamma();
 
    virtual EDisplayColorGamut GetDisplayColorGamut() const { return EDisplayColorGamut::sRGB_D65; }
    virtual EDisplayOutputFormat GetDisplayOutputFormat() const { return EDisplayOutputFormat::SDR_sRGB; }
    virtual bool GetSceneHDREnabled() const { return false; }
 
    virtual void ProcessToggleFreezeCommand() {};
 
    virtual bool HasToggleFreezeCommand() { return false; };
 
    ENGINE_API virtual bool ReadPixels(TArray<FColor>& OutImageData, FReadSurfaceDataFlags InFlags = FReadSurfaceDataFlags(RCM_UNorm, CubeFace_MAX), FIntRect InSrcRect = FIntRect(0, 0, 0, 0));
 
    ENGINE_API bool ReadPixelsPtr(FColor* OutImageBytes, FReadSurfaceDataFlags InFlags = FReadSurfaceDataFlags(RCM_UNorm, CubeFace_MAX), FIntRect InSrcRect = FIntRect(0, 0, 0, 0));
 
    UE_DEPRECATED(5.4, "Use the other ReadFloat16Pixels variant (ECubeFace can be set in FReadSurfaceDataFlags)")
    ENGINE_API bool ReadFloat16Pixels(TArray<FFloat16Color>& OutImageData, ECubeFace CubeFace);
 
    ENGINE_API virtual bool ReadFloat16Pixels(TArray<FFloat16Color>& OutImageData, FReadSurfaceDataFlags InFlags = FReadSurfaceDataFlags(RCM_UNorm, CubeFace_MAX), FIntRect InSrcRect = FIntRect(0, 0, 0, 0));
 
    ENGINE_API virtual bool ReadLinearColorPixels(TArray<FLinearColor>& OutImageData, FReadSurfaceDataFlags InFlags = FReadSurfaceDataFlags(RCM_MinMax, CubeFace_MAX), FIntRect InSrcRect = FIntRect(0, 0, 0, 0));
 
    ENGINE_API bool ReadLinearColorPixelsPtr(FLinearColor* OutImageBytes, FReadSurfaceDataFlags InFlags = FReadSurfaceDataFlags(RCM_MinMax, CubeFace_MAX), FIntRect InSrcRect = FIntRect(0, 0, 0, 0));
 
    virtual FRHIGPUMask GetGPUMask(FRHICommandListImmediate& RHICmdList) const { return FRHIGPUMask::GPU0(); }
 
protected:
 
    FTextureRHIRef RenderTargetTextureRHI;
};
 
 
class FViewportFrame
{
public:
 
    virtual class FViewport* GetViewport() = 0;
    virtual void ResizeFrame(uint32 NewSizeX,uint32 NewSizeY,EWindowMode::Type NewWindowMode) = 0;
};
 
#define MAX_HITPROXYSIZE 200
 
DECLARE_MULTICAST_DELEGATE(FOnScreenshotRequestProcessed);
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnScreenshotCaptured, int32 /*Width*/, int32 /*Height*/, const TArray<FColor>& /*Colors*/);
 
 
struct FScreenshotRequest
{
    static ENGINE_API void RequestScreenshot(bool bInShowUI);
 
    static ENGINE_API void RequestScreenshot(const FString& InFilename, bool bInShowUI, bool bAddFilenameSuffix, bool bHdrScreenshot = false, const FIntRect& InViewRect = FIntRect());
 
    static ENGINE_API void Reset();
 
    static const FString& GetFilename() { return Filename; }
 
    static bool IsScreenshotRequested() { return bIsScreenshotRequested; }
 
    static bool ShouldShowUI() { return bShowUI; }
 
    static FIntRect GetViewRect() { return ViewRect; }
 
    static ENGINE_API void CreateViewportScreenShotFilename( FString& InOutFilename );
 
    static ENGINE_API TArray<FColor>* GetHighresScreenshotMaskColorArray();
 
    static ENGINE_API FIntPoint& GetHighresScreenshotMaskExtents();
 
    static FOnScreenshotRequestProcessed& OnScreenshotRequestProcessed()
    {
        return ScreenshotProcessedDelegate;
    }
 
    static FOnScreenshotCaptured& OnScreenshotCaptured()
    {
        return ScreenshotCapturedDelegate;
    }
 
private:
    static ENGINE_API FOnScreenshotRequestProcessed ScreenshotProcessedDelegate;
    static ENGINE_API FOnScreenshotCaptured ScreenshotCapturedDelegate;
    static ENGINE_API bool bIsScreenshotRequested;
    static ENGINE_API FString NextScreenshotName;
    static ENGINE_API FString Filename;
    static ENGINE_API bool bShowUI;
    static ENGINE_API TArray<FColor> HighresScreenshotMaskColorArray;
    static ENGINE_API FIntPoint HighresScreenshotMaskExtents;
    static ENGINE_API FIntRect ViewRect;
};
 
// @param bAutoType true: automatically choose GB/MB/KB/... false: always use MB for easier comparisons
ENGINE_API FString GetMemoryString( const double Value, const bool bAutoType = true );
 
struct FStatUnitData
{
    float RenderThreadTime;
    float RenderThreadTimeCriticalPath;
    float GameThreadTime;
    float GameThreadTimeCriticalPath;
    float GPUFrameTime[MAX_NUM_GPUS];
    float GPUClockFraction[MAX_NUM_GPUS];
    float GPUUsageFraction[MAX_NUM_GPUS];
    uint64 GPUMemoryUsage[MAX_NUM_GPUS];
    float GPUExternalUsageFraction[MAX_NUM_GPUS];
    uint64 GPUExternalMemoryUsage[MAX_NUM_GPUS];
    float FrameTime;
    float RHITTime;
    float InputLatencyTime;
 
    float RawRenderThreadTime;
    float RawRenderThreadTimeCriticalPath;
    float RawGameThreadTime;
    float RawGameThreadTimeCriticalPath;
    float RawGPUFrameTime[MAX_NUM_GPUS];
    float RawGPUClockFraction[MAX_NUM_GPUS];
    float RawGPUUsageFraction[MAX_NUM_GPUS];
    uint64 RawGPUMemoryUsage[MAX_NUM_GPUS];
    float RawGPUExternalUsageFraction[MAX_NUM_GPUS];
    uint64 RawGPUExternalMemoryUsage[MAX_NUM_GPUS];
    float RawFrameTime;
    float RawRHITTime;
    float RawInputLatencyTime;
 
    double LastTime;
 
#if !UE_BUILD_SHIPPING
    static const int32 NumberOfSamples = 200;
 
    int32 CurrentIndex;
    TArray<float> RenderThreadTimes;
    TArray<float> GameThreadTimes;
    TArray<float> GPUFrameTimes[MAX_NUM_GPUS];
    TArray<float> FrameTimes;
    TArray<float> RHITTimes;
    TArray<float> InputLatencyTimes;
    DynamicRenderScaling::TMap<TArray<float>> ResolutionFractions;
#endif 
 
    FStatUnitData()
        : RenderThreadTime(0.0f)
        , RenderThreadTimeCriticalPath(0.0f)
        , GameThreadTime(0.0f)
        , GameThreadTimeCriticalPath(0.0f)
        , GPUFrameTime{ 0.0f }
        , GPUClockFraction{ 0.0f }
        , GPUUsageFraction{ 0.0f }
        , GPUExternalUsageFraction{ 0.0f }
        , FrameTime(0.0f)
        , RHITTime(0.0f)
        , InputLatencyTime(0.0f)
        , RawRenderThreadTime(0.0f)
        , RawRenderThreadTimeCriticalPath(0.0f)
        , RawGameThreadTime(0.0f)
        , RawGameThreadTimeCriticalPath(0.0f)
        , RawGPUFrameTime{ 0.0f }
        , RawGPUClockFraction{ 0.0f }
        , RawGPUUsageFraction{ 0.0f }
        , RawGPUExternalUsageFraction{ 0.0f }
        , RawFrameTime(0.0f)
        , RawRHITTime(0.0f)
        , RawInputLatencyTime(0.0f)
        , LastTime(0.0)
    {
#if !UE_BUILD_SHIPPING
        CurrentIndex = 0;
        RenderThreadTimes.AddZeroed(NumberOfSamples);
        GameThreadTimes.AddZeroed(NumberOfSamples);
        for (auto& GPUFrameTimesArray : GPUFrameTimes)
        {
            GPUFrameTimesArray.AddZeroed(NumberOfSamples);
        }
        FrameTimes.AddZeroed(NumberOfSamples);
        RHITTimes.AddZeroed(NumberOfSamples);
        InputLatencyTimes.AddZeroed(NumberOfSamples);
        for (TLinkedList<DynamicRenderScaling::FBudget*>::TIterator BudgetIt(DynamicRenderScaling::FBudget::GetGlobalList()); BudgetIt; BudgetIt.Next())
        {
            const DynamicRenderScaling::FBudget& Budget = **BudgetIt;
            ResolutionFractions[Budget].Reserve(NumberOfSamples);
            for (int32 i = 0; i < NumberOfSamples; i++)
            {
                ResolutionFractions[Budget].Add(-1.0f);
            }
        }
#endif 
    }
 
    int32 DrawStat(FViewport* InViewport, FCanvas* InCanvas, int32 InX, int32 InY);
};
 
struct FStatHitchesData
{
    double LastTime;
 
    static const int32 NumHitches = 20;
    TArray<float> Hitches;
    TArray<double> When;
    int32 OverwriteIndex;
    int32 Count;
 
    FStatHitchesData()
        : LastTime(0.0)
        , OverwriteIndex(0)
        , Count(0)
    {
        Hitches.AddZeroed(NumHitches);
        When.AddZeroed(NumHitches);
    }
 
    int32 DrawStat(FViewport* InViewport, FCanvas* InCanvas, int32 InX, int32 InY);
};
 
class FViewport : public FRenderTarget, protected FRenderResource
{
public:
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnViewportResized, FViewport*, uint32);
    ENGINE_API static FOnViewportResized ViewportResizedEvent;
 
    // Constructor.
    ENGINE_API FViewport(FViewportClient* InViewportClient);
    // Destructor
    ENGINE_API virtual ~FViewport();
 
    //~ Begin FViewport Interface.
    virtual void* GetWindow() = 0;
    virtual void MoveWindow(int32 NewPosX, int32 NewPosY, int32 NewSizeX, int32 NewSizeY) = 0;
 
    virtual void Destroy() = 0;
 
    // New MouseCapture/MouseLock API
    virtual bool HasMouseCapture() const                { return false; }
    virtual bool HasFocus() const                   { return true; }
    virtual bool IsForegroundWindow() const         { return true; }
    virtual void CaptureMouse( bool bCapture )      { }
    virtual void LockMouseToViewport( bool bLock )  { }
    virtual void ShowCursor( bool bVisible)         { }
    virtual bool UpdateMouseCursor(bool bSetCursor) { return true; }
 
    virtual void ShowSoftwareCursor( bool bVisible )        { }
    virtual void SetSoftwareCursorPosition( FVector2D Position ) { }
    virtual bool IsSoftwareCursorVisible() const { return false; }
 
    virtual bool IsCursorVisible() const { return true; }
 
    virtual bool SetUserFocus(bool bFocus) = 0;
    virtual bool KeyState(FKey Key) const = 0;
    virtual int32 GetMouseX() const = 0;
    virtual int32 GetMouseY() const = 0;
    virtual void GetMousePos(FIntPoint& MousePosition, const bool bLocalPosition = true) = 0;
    virtual float GetTabletPressure() { return 0.f; }
    virtual bool IsPenActive() { return false; }
    virtual void SetMouse(int32 x, int32 y) = 0;
    virtual bool IsFullscreen() const { return WindowMode == EWindowMode::Fullscreen || WindowMode == EWindowMode::WindowedFullscreen; }
    virtual bool IsExclusiveFullscreen() const { return WindowMode == EWindowMode::Fullscreen; }
    virtual EWindowMode::Type GetWindowMode()   const { return WindowMode; }
    virtual void ProcessInput( float DeltaTime ) = 0;
 
    virtual FVector2D VirtualDesktopPixelToViewport(FIntPoint VirtualDesktopPointPx) const = 0;
 
    virtual FIntPoint ViewportToVirtualDesktopPixel(FVector2D ViewportCoordinate) const = 0;
 
    virtual FCanvas* GetDebugCanvas() { return NULL; };
 
    virtual void SetRequiresVsync(bool bShouldVsync) {}
 
    virtual void SetPreCaptureMousePosFromSlateCursor() {}
 
    ENGINE_API virtual void EnqueueBeginRenderFrame(const bool bShouldPresent);
 
    ENGINE_API virtual void EnqueueEndRenderFrame(const bool bLockToVsync, const bool bShouldPresent);
 
    ENGINE_API virtual void BeginRenderFrame(FRHICommandListImmediate& RHICmdList);
 
    ENGINE_API virtual void EndRenderFrame(FRHICommandListImmediate& RHICmdList, bool bPresent, bool bLockToVsync);
 
    ENGINE_API virtual FRHIGPUMask GetGPUMask(FRHICommandListImmediate& RHICmdList) const override;
 
    virtual bool IsKeyboardAvailable( int32 ControllerID ) const { return true; }
 
    virtual bool IsMouseAvailable( int32 ControllerID ) const { return true; }
 
 
    virtual float GetDesiredAspectRatio() const
    {
        FIntPoint Size = GetSizeXY();
        return (float)Size.X / (float)Size.Y;
    }
 
    virtual void InvalidateDisplay() = 0;
 
    ENGINE_API void Draw( bool bShouldPresent = true );
 
    ENGINE_API virtual void DeferInvalidateHitProxy();
 
    ENGINE_API void InvalidateHitProxy();
 
    ENGINE_API void Invalidate();
 
    ENGINE_API const TArray<FColor>& GetRawHitProxyData(FIntRect InRect);
 
    ENGINE_API void GetHitProxyMap(FIntRect InRect, TArray<HHitProxy*>& OutMap);
 
    ENGINE_API HHitProxy* GetHitProxy(int32 X,int32 Y);
 
    ENGINE_API void GetActorsAndModelsInHitProxy(FIntRect InRect, TSet<AActor*>& OutActors, TSet<UModel*>& OutModels);
 
    ENGINE_API FTypedElementHandle GetElementHandleAtPoint(int32 X, int32 Y);
 
    ENGINE_API void GetElementHandlesInRect(FIntRect InRect, FTypedElementListRef OutElementHandles);
 
    ENGINE_API void EnumerateHitProxiesInRect(FIntRect InRect, TFunctionRef<bool(HHitProxy*)> InCallback);
    
    virtual FViewportFrame* GetViewportFrame() = 0;
 
    ENGINE_API FIntRect CalculateViewExtents(float AspectRatio, const FIntRect& ViewRect);
    
    ENGINE_API static FIntRect CalculateViewExtents(float AspectRatio, float DesiredAspectRatio, const FIntRect& ViewRect, const FIntPoint& DestSize);
 
    ENGINE_API virtual void SetViewportClient( FViewportClient* InViewportClient );
 
    //~ Begin FRenderTarget Interface.
    virtual FIntPoint GetSizeXY() const override { return FIntPoint(SizeX, SizeY); }
    FIntPoint GetInitialPositionXY() const { return FIntPoint(InitialPositionX, InitialPositionY); }
    // Accessors.
    FViewportClient* GetClient() const { return ViewportClient; }
 
    ENGINE_API static void SetGameRenderingEnabled(bool bIsEnabled, int32 PresentAndStopMovieDelay=0);
 
    static bool IsGameRenderingEnabled() { return bIsGameRenderingEnabled; }
 
    ENGINE_API virtual void ProcessToggleFreezeCommand() override;
 
    ENGINE_API virtual bool HasToggleFreezeCommand() override;
 
    const FViewportRHIRef& GetViewportRHI() const { return ViewportRHI; }
 
    void UpdateRenderTargetSurfaceRHIToCurrentBackBuffer();
 
    virtual int32 DrawStatsHUD (FCanvas* InCanvas, const int32 InX, const int32 InY)
    {
        return InY;
    }
 
    ENGINE_API void SetInitialSize( FIntPoint InitialSizeXY );
 
    bool IsPlayInEditorViewport() const
    {
        return bIsPlayInEditorViewport;
    }
 
    void SetPlayInEditorViewport( bool bInPlayInEditorViewport )
    {
        bIsPlayInEditorViewport = bInPlayInEditorViewport;
    }
 
    bool IsSlateViewport() const { return bIsSlateViewport; }
 
    bool IsHDRViewport() const { return bIsHDR; }
 
    void SetHDRMode( bool bHDR) { bIsHDR = bHDR; }
 
    FString AppVersionString;
 
    ENGINE_API bool TakeHighResScreenShot();
 
    virtual bool IsStereoRenderingAllowed() const { return false; }
 
    virtual FIntPoint GetRenderTargetTextureSizeXY() const { return GetSizeXY(); }
 
    inline FName GetViewportType() const { return ViewportType; }
 
protected:
 
    FViewportClient* ViewportClient;
 
    ENGINE_API virtual void UpdateViewportRHI(bool bDestroyed, uint32 NewSizeX, uint32 NewSizeY, EWindowMode::Type NewWindowMode, EPixelFormat PreferredPixelFormat);
 
    void HighResScreenshot();
 
    class FHitProxyMap : public FHitProxyConsumer, public FRenderTarget, public FGCObject
    {
    public:
 
        FHitProxyMap();
 
        ENGINE_API virtual ~FHitProxyMap();
 
        void Init(uint32 NewSizeX,uint32 NewSizeY);
 
        void Release();
 
        void Invalidate();
 
        //~ Begin FHitProxyConsumer Interface.
        virtual void AddHitProxy(HHitProxy* HitProxy) override;
 
        //~ Begin FRenderTarget Interface.
        virtual FIntPoint GetSizeXY() const override { return FIntPoint(SizeX, SizeY); }
 
        virtual void AddReferencedObjects( FReferenceCollector& Collector ) override;
        virtual FString GetReferencerName() const override;
 
        const FTextureRHIRef& GetHitProxyTexture(void) const        { return RenderTargetTextureRHI; }
        const FTextureRHIRef& GetHitProxyCPUTexture(void) const     { return HitProxyCPUTexture; }
 
    private:
 
        uint32 SizeX;
 
        uint32 SizeY;
 
        TArray<TRefCountPtr<HHitProxy> > HitProxies;
 
        FTextureRHIRef HitProxyCPUTexture;
    };
 
    FHitProxyMap HitProxyMap;
 
    TArray<FColor> CachedHitProxyData;
 
    FViewportRHIRef ViewportRHI;
 
    uint32 InitialPositionX;
 
    uint32 InitialPositionY;
 
    uint32 SizeX;
 
    uint32 SizeY;
 
    uint32 HitProxySize;
 
    EWindowMode::Type WindowMode;
 
    uint32 bRequiresHitProxyStorage : 1;
 
    uint32 bHitProxiesCached : 1;
 
    uint32 bHasRequestedToggleFreeze : 1;
 
    uint32 bIsPlayInEditorViewport : 1;
 
    uint32 bIsSlateViewport : 1;
 
    uint32 bIsHDR : 1;
 
    FName ViewportType;
 
    ENGINE_API static bool bIsGameRenderingEnabled;
 
    static int32 PresentAndStopMovieDelay;
 
    bool bTakeHighResScreenShot;
 
    //~ Begin FRenderResource Interface.
    ENGINE_API virtual void ReleaseRHI() override;
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
};
 
// Shortcuts for checking the state of both left&right variations of control keys.
extern ENGINE_API bool IsCtrlDown(FViewport* Viewport);
extern ENGINE_API bool IsShiftDown(FViewport* Viewport);
extern ENGINE_API bool IsAltDown(FViewport* Viewport);
 
extern ENGINE_API bool GetViewportScreenShot(FViewport* Viewport, TArray<FColor>& Bitmap, const FIntRect& ViewRect = FIntRect(), const FReadSurfaceDataFlags& ReadSurfaceFlags = FReadSurfaceDataFlags());
extern ENGINE_API bool GetViewportScreenShotHDR(FViewport* Viewport, TArray<FLinearColor>& Bitmap, const FIntRect& ViewRect = FIntRect(), const FReadSurfaceDataFlags& ReadSurfaceFlags = FReadSurfaceDataFlags(RCM_MinMax));
extern ENGINE_API bool GetHighResScreenShotInput(const TCHAR* Cmd, FOutputDevice& Ar, uint32& OutXRes, uint32& OutYRes, float& OutResMult, FIntRect& OutCaptureRegion, bool& OutShouldEnableMask, bool& OutDumpBufferVisualizationTargets, bool& OutCaptureHDR, FString& OutFilenameOverride, bool& OutUseDateTimeAsFileName);
 
extern ENGINE_API class FCommonViewportClient* GStatProcessingViewportClient;