SceneViewport.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "CoreMinimal.h"
#include "InputCoreTypes.h"
#include "Layout/Geometry.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Input/PopupMethodReply.h"
#include "Widgets/SWidget.h"
#include "Rendering/RenderingCommon.h"
#include "Textures/SlateShaderResource.h"
#include "UnrealClient.h"
 
class FCanvas;
class FDebugCanvasDrawer;
class FSlateRenderer;
class FSlateWindowElementList;
class SViewport;
class SWindow;
 
DECLARE_DELEGATE_OneParam( FOnSceneViewportResize, FVector2D );
 
class SViewport;
 
extern const FName NAME_SceneViewport;
 
class FSceneViewport : public FViewportFrame, public FViewport, public ISlateViewport
{
public:
    ENGINE_API FSceneViewport( FViewportClient* InViewportClient, TSharedPtr<SViewport> InViewportWidget );
    ENGINE_API ~FSceneViewport();
 
    virtual void* GetWindow() override { return NULL; }
 
    virtual void MoveWindow(int32 NewPosX, int32 NewPosY, int32 NewSizeX, int32 NewSizeY) override {}
    ENGINE_API virtual bool HasMouseCapture() const override;
    ENGINE_API virtual bool HasFocus() const override;
    ENGINE_API virtual bool IsForegroundWindow() const override;
    ENGINE_API virtual void CaptureMouse( bool bCapture ) override;
    ENGINE_API virtual void LockMouseToViewport( bool bLock ) override;
    ENGINE_API virtual void ShowCursor( bool bVisible ) override;
    ENGINE_API virtual void SetPreCaptureMousePosFromSlateCursor() override;
    virtual bool IsCursorVisible() const override { return bIsCursorVisible; }
    virtual void ShowSoftwareCursor( bool bVisible ) override { bIsSoftwareCursorVisible = bVisible; }
    virtual void SetSoftwareCursorPosition( FVector2D Position ) override { SoftwareCursorPosition = Position; }
    virtual bool IsSoftwareCursorVisible() const override { return bIsSoftwareCursorVisible; }
    virtual FVector2D GetSoftwareCursorPosition() const override { return SoftwareCursorPosition; }
    ENGINE_API virtual FCanvas* GetDebugCanvas() override;
    ENGINE_API virtual float GetDisplayGamma() const override;
    ENGINE_API virtual void EnqueueEndRenderFrame(const bool bLockToVsync, const bool bShouldPresent) override;
 
    ENGINE_API virtual const FTextureRHIRef& GetRenderTargetTexture() const;
 
    ENGINE_API virtual void SetRenderTargetTextureRenderThread(FTextureRHIRef& RT);
 
    ENGINE_API virtual bool SetUserFocus(bool bFocus) override;
 
    ENGINE_API virtual bool KeyState(FKey Key) const override;
 
    ENGINE_API virtual int32 GetMouseX() const override;
 
    ENGINE_API virtual int32 GetMouseY() const override;
 
    ENGINE_API virtual void GetMousePos( FIntPoint& MousePosition, const bool bLocalPosition = true) override;
 
    ENGINE_API virtual void SetMouse( int32 X, int32 Y ) override;
 
    ENGINE_API virtual void ProcessInput( float DeltaTime ) override;
    
    ENGINE_API virtual FVector2D VirtualDesktopPixelToViewport(FIntPoint VirtualDesktopPointPx) const override;
    ENGINE_API virtual FIntPoint ViewportToVirtualDesktopPixel(FVector2D ViewportCoordinate) const override;
 
    ENGINE_API virtual void InvalidateDisplay() override;
 
    ENGINE_API virtual void DeferInvalidateHitProxy() override;
 
    virtual FViewport* GetViewport() override { return this; }
    virtual FViewportFrame* GetViewportFrame() override { return this; }
 
    TWeakPtr<SViewport> GetViewportWidget() const { return ViewportWidget; }
 
    ENGINE_API virtual void EnqueueBeginRenderFrame(const bool bShouldPresent) override;
 
    ENGINE_API virtual void BeginRenderFrame(FRHICommandListImmediate& RHICmdList) override;
 
    ENGINE_API virtual void EndRenderFrame(FRHICommandListImmediate& RHICmdList, bool bPresent, bool bLockToVsync) override;
 
    ENGINE_API virtual void Tick( const FGeometry& AllottedGeometry, double InCurrentTime, float InDeltaTime ) override;
 
    ENGINE_API void OnPlayWorldViewportSwapped( const FSceneViewport& OtherViewport );
 
    ENGINE_API void SwapStatCommands(const FSceneViewport& OtherViewport);
 
    virtual void SetRequiresVsync(bool bShouldVsync) override { bRequiresVsync = bShouldVsync; }
 
    virtual bool RequiresVsync() const override { return bRequiresVsync; }
 
    ENGINE_API virtual void ResizeFrame(uint32 NewSizeX,uint32 NewSizeY,EWindowMode::Type NewWindowMode) override;
 
    void SetOnSceneViewportResizeDel(FOnSceneViewportResize InOnSceneViewportResize) 
    { 
        OnSceneViewportResizeDel = InOnSceneViewportResize; 
    }
 
    void SetPlayInEditorGetsMouseControl(const bool bGetsMouseControl)
    {
        bShouldCaptureMouseOnActivate = bGetsMouseControl;
    }
 
    void SetPlayInEditorIsSimulate(const bool bIsSimulate)
    {
        bPlayInEditorIsSimulate = bIsSimulate;
    }
    bool GetPlayInEditorIsSimulate() const
    {
        return bPlayInEditorIsSimulate;
    }
 
    ENGINE_API virtual void UpdateViewportRHI(bool bDestroyed, uint32 NewSizeX, uint32 NewSizeY, EWindowMode::Type NewWindowMode, EPixelFormat PreferredPixelFormat) override;
 
    ENGINE_API virtual FSlateShaderResource* GetViewportRenderTargetTexture() const override;
    ENGINE_API virtual void OnDrawViewport( const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) override;
    ENGINE_API virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) override;
    ENGINE_API virtual TOptional<TSharedRef<SWidget>> OnMapCursor(const FCursorReply& CursorReply) override;
    ENGINE_API virtual FReply OnMouseButtonDown( const FGeometry& InGeometry, const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual FReply OnMouseButtonUp( const FGeometry& InGeometry, const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual void OnMouseEnter( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual void OnMouseLeave( const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual FReply OnMouseMove( const FGeometry& InGeometry, const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual FReply OnMouseWheel( const FGeometry& InGeometry, const FPointerEvent& MouseEvent ) override;
    ENGINE_API virtual FReply OnMouseButtonDoubleClick( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent ) override;
    ENGINE_API virtual FReply OnTouchStarted( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent ) override;
    ENGINE_API virtual FReply OnTouchMoved( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent ) override;
    ENGINE_API virtual FReply OnTouchEnded( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent ) override;
    ENGINE_API virtual FReply OnTouchForceChanged(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent) override;
    ENGINE_API virtual FReply OnTouchFirstMove(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent) override;
    ENGINE_API virtual FReply OnTouchGesture(const FGeometry& MyGeometry, const FPointerEvent& InGestureEvent) override;
    ENGINE_API virtual FReply OnMotionDetected( const FGeometry& MyGeometry, const FMotionEvent& InMotionEvent ) override;
    ENGINE_API virtual FPopupMethodReply OnQueryPopupMethod() const override;
    ENGINE_API virtual bool HandleNavigation(const uint32 InUserIndex, TSharedPtr<SWidget> InDestination) override;
    ENGINE_API virtual TOptional<bool> OnQueryShowFocus(const EFocusCause InFocusCause) const override;
    ENGINE_API virtual void OnFinishedPointerInput() override;
    ENGINE_API virtual FReply OnKeyDown( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent ) override;
    ENGINE_API virtual FReply OnKeyUp( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent ) override;
    ENGINE_API virtual FReply OnAnalogValueChanged( const FGeometry& MyGeometry, const FAnalogInputEvent& InAnalogInputEvent ) override;
    ENGINE_API virtual FReply OnKeyChar( const FGeometry& InGeometry, const FCharacterEvent& InCharacterEvent ) override;
    ENGINE_API virtual FReply OnFocusReceived( const FFocusEvent& InFocusEvent ) override;
    ENGINE_API virtual void OnFocusLost( const FFocusEvent& InFocusEvent ) override;
    ENGINE_API virtual void OnViewportClosed() override;
    ENGINE_API virtual FReply OnRequestWindowClose() override;
    ENGINE_API virtual TWeakPtr<SWidget> GetWidget() override;
    ENGINE_API virtual FReply OnViewportActivated(const FWindowActivateEvent& InActivateEvent) override;
    ENGINE_API virtual void OnViewportDeactivated(const FWindowActivateEvent& InActivateEvent) override;
    virtual FIntPoint GetSize() const override { return GetSizeXY(); }
    ENGINE_API virtual EDisplayColorGamut GetDisplayColorGamut() const override;
    ENGINE_API virtual EDisplayOutputFormat GetDisplayOutputFormat() const override;
    ENGINE_API virtual bool GetSceneHDREnabled() const override;
    ENGINE_API virtual ESlateViewportDynamicRange GetViewportDynamicRange() const override;
 
    ENGINE_API void SetViewportSize(uint32 NewSizeX,uint32 NewSizeY);
    ENGINE_API void SetFixedViewportSize(uint32 NewSizeX, uint32 NewSizeY);
 
    ENGINE_API bool HasFixedSize() const;
 
    ENGINE_API TSharedPtr<SWindow> FindWindow();
 
    ENGINE_API virtual bool IsStereoRenderingAllowed() const override;
 
    virtual FIntPoint GetRenderTargetTextureSizeXY() const { return (RTTSize.X != 0) ? RTTSize : GetSizeXY(); }
 
    EPixelFormat GetSceneTargetFormat() const override { return SceneTargetFormat; }
 
    const FGeometry& GetCachedGeometry() const { return CachedGeometry; }
 
    void SetGammaOverride(const float InGammaOverride)
    {
        ViewportGammaOverride = InGammaOverride;
    };
 
    ENGINE_API void SetDebugCanvas(TSharedPtr<class SDebugCanvas> InDebugCanvas);
 
    ENGINE_API void PaintDebugCanvas(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId) const;
 
private:
    ENGINE_API void Destroy() override;
 
    // FRenderResource interface.
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
 
    virtual FString GetFriendlyName() const override { return FString(TEXT("FSlateSceneViewport"));}
 
    ENGINE_API virtual void ResizeViewport( uint32 NewSizeX,uint32 NewSizeY,EWindowMode::Type NewWindowMode );
 
    ENGINE_API void ProcessAccumulatedPointerInput();
 
    ENGINE_API void UpdateCachedCursorPos( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
 
    ENGINE_API void UpdateCachedGeometry( const FGeometry& InGeometry );
 
    ENGINE_API void UpdateModifierKeys( const FPointerEvent& InMouseEvent );
 
    ENGINE_API void ApplyModifierKeys(const FModifierKeysState& InKeysState, const uint64 Timestamp);
 
    ENGINE_API FReply AcquireFocusAndCapture(FIntPoint MousePosition, EFocusCause FocusCause = EFocusCause::SetDirectly);
 
    ENGINE_API bool IsCurrentlyGameViewport();
 
    UE_DEPRECATED(5.5, "WindowRenderTargetUpdate is no longer used")
    void WindowRenderTargetUpdate(FSlateRenderer* Renderer, SWindow* Window) {}
 
    bool UseSeparateRenderTarget() const override
    {
        return bUseSeparateRenderTarget || bForceSeparateRenderTarget;
    }
 
    ENGINE_API bool IsStereoscopic3D() const override;
 
    ENGINE_API void OnWindowBackBufferResourceDestroyed(void* Backbuffer);
 
    ENGINE_API void OnPreResizeWindowBackbuffer(void* Backbuffer);
 
    ENGINE_API void OnPostResizeWindowBackbuffer(void* Backbuffer);
 
 
    ENGINE_API bool IsInPermanentCapture();
 
private:
    FReply CurrentReplyState;
    TMap<FKey,bool> KeyStateMap;
    FIntPoint CachedCursorPos;
    FGeometry CachedGeometry;
    FIntPoint PreCaptureCursorPos;
    FVector2D SoftwareCursorPosition;
    bool bIsSoftwareCursorVisible;  
    TSharedPtr<class FDebugCanvasDrawer, ESPMode::ThreadSafe> DebugCanvasDrawer;
    TWeakPtr<SViewport> ViewportWidget;
    TWeakPtr<SDebugCanvas> DebugCanvas;
    int32 NumMouseSamplesX;
    int32 NumMouseSamplesY;
    int32 MouseDeltaUserIndex;
    FIntPoint MouseDelta;
    bool bIsCursorVisible;
    bool bShouldCaptureMouseOnActivate;
    bool bRequiresVsync;
    bool bUseSeparateRenderTarget;
    bool bForceSeparateRenderTarget;
    bool bIsResizing;
    bool bForceViewportSize;
    FOnSceneViewportResize OnSceneViewportResizeDel;
    bool bPlayInEditorIsSimulate;
    bool bCursorHiddenDueToCapture;
    bool bHDRViewport;
    FIntPoint MousePosBeforeHiddenDueToCapture;
    FIntPoint RTTSize;
    EPixelFormat SceneTargetFormat;
 
    TArray<class FSlateRenderTargetRHI*> BufferedSlateHandles;
    TArray<FTextureRHIRef> BufferedRenderTargetsRHI;
    TArray<FTextureRHIRef> BufferedShaderResourceTexturesRHI;
 
    FTextureRHIRef RenderTargetTextureRenderThreadRHI;
    class FSlateRenderTargetRHI* RenderThreadSlateTexture;
 
    int32 CurrentBufferedTargetIndex;
    int32 NextBufferedTargetIndex;
 
    int32 NumTouches;
 
    EDisplayColorGamut DisplayColorGamut;
    EDisplayOutputFormat DisplayOutputFormat;
 
    TOptional<float> ViewportGammaOverride;
};