ViewportClient.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Engine/EngineBaseTypes.h"
#include "GenericPlatform/ICursor.h"
#include "InputCoreTypes.h"
#include "Misc/DateTime.h"
 
class FCanvas;
class FCursorReply;
class FViewport;
class FPopupMethodReply;
class FWindowActivateEvent;
class SWidget;
enum class EFocusCause : uint8;
enum class EGestureEvent : uint8;
struct FInputKeyEventArgs;
struct FKey;
struct FStatHitchesData;
struct FStatUnitData;
 
class FViewportClient
{
public:
    virtual ~FViewportClient(){}
    virtual void Precache() {}
    ENGINE_API virtual void RedrawRequested(FViewport* Viewport);
    ENGINE_API virtual void RequestInvalidateHitProxy(FViewport* Viewport);
    virtual void Draw(FViewport* Viewport,FCanvas* Canvas) {}
    virtual bool ProcessScreenShots(FViewport* Viewport) { return false; }
    virtual UWorld* GetWorld() const { return NULL; }
    virtual struct FEngineShowFlags* GetEngineShowFlags() { return NULL; }
 
    virtual bool InputKey(const FInputKeyEventArgs& EventArgs) { return false; }
 
    UE_DEPRECATED(5.6, "Use the version of InputAxis which takes in a FInputKeyEventArgs instead.")
    ENGINE_API virtual bool InputAxis(
        FViewport* Viewport,
        FInputDeviceId InputDevice,
        FKey Key,
        float Delta,
        float DeltaTime,
        int32 NumSamples = 1,
        bool bGamepad = false) final;
 
    virtual bool InputAxis(const FInputKeyEventArgs& Args) { return false; }
    
    virtual bool InputChar(FViewport* Viewport,int32 ControllerId,TCHAR Character) { return false; }
 
    UE_DEPRECATED(5.6, "Use the version which takes a uint64 timestamp instead")
    ENGINE_API virtual bool InputTouch(FViewport* Viewport, int32 ControllerId, uint32 Handle, ETouchType::Type Type, const FVector2D& TouchLocation, float Force, FDateTime DeviceTimestamp, uint32 TouchpadIndex) final;
 
    virtual bool InputTouch(
        FViewport* Viewport,
        const FInputDeviceId DeviceId,
        uint32 Handle,
        ETouchType::Type Type,
        const FVector2D& TouchLocation,
        float Force,        
        uint32 TouchpadIndex,
        const uint64 Timestamp)
    {
        return false;
    }
 
    UE_DEPRECATED(5.6, "Use the version which takes in a FInputDeviceId and uint64 Timestamp instead.")
    ENGINE_API virtual bool InputGesture(FViewport* Viewport, EGestureEvent GestureType, const FVector2D& GestureDelta, bool bIsDirectionInvertedFromDevice) final;
 
    virtual bool InputGesture(
        FViewport* Viewport,
        const FInputDeviceId DeviceId,
        EGestureEvent GestureType,
        const FVector2D& GestureDelta,
        bool bIsDirectionInvertedFromDevice,
        const uint64 Timestamp)
    {
        return false;
    }
 
    UE_DEPRECATED(5.6, "Use the version which takes in a FInputDeviceId and a timestamp instead")
    ENGINE_API virtual bool InputMotion(FViewport* Viewport, int32 ControllerId, const FVector& Tilt, const FVector& RotationRate, const FVector& Gravity, const FVector& Acceleration) final;
 
    virtual bool InputMotion(
        FViewport* Viewport,
        const FInputDeviceId DeviceId,
        const FVector& Tilt,
        const FVector& RotationRate,
        const FVector& Gravity,
        const FVector& Acceleration,
        const uint64 Timestamp)
    {
        return false;
    }
 
    virtual void SetIsSimulateInEditorViewport(bool bInIsSimulateInEditorViewport) { };
 
    UE_DEPRECATED(5.6, "This function will be removed in a future release.")
    virtual bool WantsPollingMouseMovement(void) const { return true; }
 
    virtual void MouseEnter( FViewport* Viewport,int32 x, int32 y ) {}
 
    virtual void MouseLeave( FViewport* Viewport ) {}
 
    virtual void MouseMove(FViewport* Viewport,int32 X,int32 Y) {}
 
    virtual void CapturedMouseMove( FViewport* InViewport, int32 InMouseX, int32 InMouseY ) { }
 
    virtual void ProcessAccumulatedPointerInput(FViewport* InViewport) {};
 
    virtual EMouseCursor::Type GetCursor(FViewport* Viewport, int32 X,int32 Y) { return EMouseCursor::Default; }
 
    ENGINE_API virtual TOptional<TSharedRef<SWidget>> MapCursor(FViewport* Viewport, const FCursorReply& CursorReply);
 
    virtual TOptional<bool> QueryShowFocus(const EFocusCause InFocusCause) const { return TOptional<bool>(); }
 
    virtual void LostFocus(FViewport* Viewport) {}
    virtual void ReceivedFocus(FViewport* Viewport) {}
    virtual bool IsFocused(FViewport* Viewport) { return true; }
 
    virtual void Activated(FViewport* Viewport, const FWindowActivateEvent& InActivateEvent) {}
    virtual void Deactivated(FViewport* Viewport, const FWindowActivateEvent& InActivateEvent) {}
 
    virtual bool IsInPermanentCapture()
    { 
        return  !GIsEditor && ((GetMouseCaptureMode() == EMouseCaptureMode::CapturePermanently) ||
            (GetMouseCaptureMode() == EMouseCaptureMode::CapturePermanently_IncludingInitialMouseDown));
    }
 
    virtual bool WindowCloseRequested() { return true; }
 
    virtual void CloseRequested(FViewport* Viewport) {}
 
    virtual bool RequiresHitProxyStorage() { return true; }
 
    virtual bool RequiresUncapturedAxisInput() const { return false; }
 
    virtual bool RequiresKeyboardInput() const { return true; }
 
    virtual bool IsOrtho() const { return false; }
 
    virtual bool IsInGameView() const { return false; }
 
    virtual class UWorld* ConditionalSetWorld() { return NULL; }
 
    virtual void ConditionalRestoreWorld( class UWorld* InWorld ) {}
 
    virtual bool OverrideHighResScreenshotCaptureRegion(FIntRect& OutCaptureRegion) { return false; }
 
    virtual FStatUnitData* GetStatUnitData() const { return NULL; }
 
    virtual FStatHitchesData* GetStatHitchesData() const { return NULL; }
 
    virtual const TArray<FString>* GetEnabledStats() const { return NULL; }
 
    virtual void SetEnabledStats(const TArray<FString>& InEnabledStats) {}
 
    virtual bool IsStatEnabled(const FString& InName) const { return false; }
 
    virtual void SetShowStats(bool bWantStats) { }
 
    virtual bool IgnoreInput() { return false; }
 
    virtual EMouseCaptureMode GetMouseCaptureMode() const { return EMouseCaptureMode::CapturePermanently; }
 
    virtual bool CaptureMouseOnLaunch() { return true; }
 
    virtual bool LockDuringCapture() { return true; }
 
    virtual bool ShouldAlwaysLockMouse() { return false; }
 
    virtual bool HideCursorDuringCapture() const { return false; }
 
    ENGINE_API virtual FPopupMethodReply OnQueryPopupMethod() const;
 
    virtual bool HandleNavigation(const uint32 InUserIndex, TSharedPtr<SWidget> InDestination) { return false; }
 
    virtual bool ShouldDPIScaleSceneCanvas() const { return true; }
 
    virtual float GetDPIScale() const { return 1.0f; }
};
 
class FCommonViewportClient : public FViewportClient
{
public:
    FCommonViewportClient()
        : CachedDPIScale(1.0f)
        , bShouldUpdateDPIScale(true)
    {}
 
    ENGINE_API virtual ~FCommonViewportClient() override;
 
    ENGINE_API void RequestUpdateDPIScale();
 
    ENGINE_API float GetDPIDerivedResolutionFraction() const;
 
    ENGINE_API virtual float GetDPIScale() const override;
 
    ENGINE_API void DrawHighResScreenshotCaptureRegion(FCanvas& Canvas);
 
protected:
    virtual float UpdateViewportClientWindowDPIScale() const { return 1.0; }
 
private:
    mutable float CachedDPIScale;
    mutable bool bShouldUpdateDPIScale;
};