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

#include "EditorViewportClient.h"
#include "PreviewScene.h"
#include "HAL/FileManager.h"
#include "Misc/FileHelper.h"
#include "Misc/Paths.h"
#include "Misc/CoreDelegates.h"
#include "Misc/App.h"
#include "Modules/ModuleManager.h"
#include "Framework/Application/SlateApplication.h"
#include "EditorStyleSet.h"
#include "CanvasItem.h"
#include "Engine/Canvas.h"
#include "Settings/LevelEditorViewportSettings.h"
#include "Settings/LevelEditorMiscSettings.h"
#include "Engine/RendererSettings.h"
#include "Components/DirectionalLightComponent.h"
#include "Components/BillboardComponent.h"
#include "Audio/AudioDebug.h"
#include "Debug/DebugDrawService.h"
#include "EngineUtils.h"
#include "Editor.h"
#include "LevelEditorViewport.h"
#include "EditorModes.h"
#include "MouseDeltaTracker.h"
#include "CameraController.h"
#include "Editor/Matinee/Public/IMatinee.h"
#include "Editor/Matinee/Public/MatineeConstants.h"
#include "HighResScreenshot.h"
#include "EditorDragTools.h"
#include "Editor/MeshPaintMode/Public/MeshPaintEdMode.h"
#include "EngineAnalytics.h"
#include "AnalyticsEventAttribute.h"
#include "Interfaces/IAnalyticsProvider.h"
#include "Matinee/MatineeActor.h"
#include "EngineModule.h"
#include "Framework/Notifications/NotificationManager.h"
#include "Widgets/Notifications/SNotificationList.h"
#include "Components/LineBatchComponent.h"
#include "SEditorViewport.h"
#include "AssetEditorModeManager.h"
#include "PixelInspectorModule.h"
#include "IHeadMountedDisplay.h"
#include "IXRTrackingSystem.h"
#include "IXRCamera.h"
#include "SceneViewExtension.h"
#include "LegacyScreenPercentageDriver.h"
#include "ComponentRecreateRenderStateContext.h"
#include "EditorBuildUtils.h"
#include "AudioDevice.h"
#include "EditorWorldExtension.h"
#include "ViewportWorldInteraction.h"
#include "Editor/EditorPerformanceSettings.h"
#include "ImageWriteQueue.h"
#include "DebugViewModeHelpers.h"
#include "RayTracingDebugVisualizationMenuCommands.h"
#include "Misc/ScopedSlowTask.h"
#include "UnrealEngine.h"
#include "BufferVisualizationData.h"

#include "CustomEditorStaticScreenPercentage.h"

ICustomEditorStaticScreenPercentage* GCustomEditorStaticScreenPercentage = nullptr;

#define LOCTEXT_NAMESPACE "EditorViewportClient"

const EViewModeIndex FEditorViewportClient::DefaultPerspectiveViewMode = VMI_Lit;
const EViewModeIndex FEditorViewportClient::DefaultOrthoViewMode       = VMI_BrushWireframe;

static TAutoConsoleVariable<int32> CVarAlignedOrthoZoom(
    TEXT("r.Editor.AlignedOrthoZoom"),
    1,
    TEXT("Only affects the editor ortho viewports.\n")
        TEXT(" 0: Each ortho viewport zoom in defined by the viewport width\n")
            TEXT(" 1: All ortho viewport zoom are locked to each other to allow axis lines to be aligned with each other."),
    ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarEditorViewportTest(
    TEXT("r.Test.EditorConstrainedView"),
    0,
    TEXT("Allows to test different viewport rectangle configuations (in game only) as they can happen when using Matinee/Editor.\n")
        TEXT("0: off(default)\n")
            TEXT("1..7: Various Configuations"),
    ECVF_RenderThreadSafe);

static bool GetDefaultLowDPIPreviewValue()
{
    static auto CVarEnableEditorScreenPercentageOverride = IConsoleManager::Get().FindConsoleVariable(TEXT("Editor.OverrideDPIBasedEditorViewportScaling"));
    return CVarEnableEditorScreenPercentageOverride->GetInt() == 0;
}

float ComputeOrthoZoomFactor(const float ViewportWidth)
{
    float Ret = 1.0f;

    if (CVarAlignedOrthoZoom.GetValueOnGameThread())
    {
        // We want to have all ortho view ports scale the same way to have the axis aligned with each other.
        // So we take out the usual scaling of a view based on it's width.
        // That means when a view port is resized in x or y it shows more content, not the same content larger (for x) or has no effect (for y).
        // 500 is to get good results with existing view port settings.
        Ret = ViewportWidth / 500.0f;
    }

    return Ret;
}

void PixelInspectorRealtimeManagement(FEditorViewportClient* CurrentViewport, bool bMouseEnter)
{
    FPixelInspectorModule& PixelInspectorModule = FModuleManager::LoadModuleChecked<FPixelInspectorModule>(TEXT("PixelInspectorModule"));
    bool bViewportIsRealtime                    = CurrentViewport->IsRealtime();
    bool bViewportShouldBeRealtime              = PixelInspectorModule.GetViewportRealtime(CurrentViewport->ViewIndex, bViewportIsRealtime, bMouseEnter);
    if (bViewportIsRealtime != bViewportShouldBeRealtime)
    {
        CurrentViewport->SetRealtime(bViewportShouldBeRealtime);
    }
}

namespace EditorViewportClient
{
static const float GridSize      = 2048.0f;
static const int32 CellSize      = 16;
static const float LightRotSpeed = 0.22f;
}  // namespace EditorViewportClient

// MIN_ORTHOZOOM defined in ULevelEditorViewportSettings
#define MAX_ORTHOZOOM				MAX_FLT /* Limit of 2D viewport zoom out */

namespace OrbitConstants
{
const float OrbitPanSpeed        = 1.0f;
const float IntialLookAtDistance = 1024.f;
}  // namespace OrbitConstants

namespace FocusConstants
{
const float TransitionTime = 0.25f;
}

namespace PreviewLightConstants
{
const float MovingPreviewLightTimerDuration = 1.0f;

const float MinMouseRadius                  = 100.0f;
const float MinArrowLength                  = 10.0f;
const float ArrowLengthToSizeRatio          = 0.1f;
const float MouseLengthToArrowLenghtRatio   = 0.2f;

const float ArrowLengthToThicknessRatio     = 0.05f;
const float MinArrowThickness               = 2.0f;

// Note: MinMouseRadius must be greater than MinArrowLength
}  // namespace PreviewLightConstants

/**
 * Cached off joystick input state
 */
class FCachedJoystickState
{
public:
    uint32 JoystickType;
    TMap<FKey, float> AxisDeltaValues;
    TMap<FKey, EInputEvent> KeyEventValues;
};

FViewportCameraTransform::FViewportCameraTransform()
    : TransitionCurve(new FCurveSequence(0.0f, FocusConstants::TransitionTime, ECurveEaseFunction::CubicOut)), ViewLocation(FVector::ZeroVector), ViewRotation(FRotator::ZeroRotator), DesiredLocation(FVector::ZeroVector), LookAt(FVector::ZeroVector), StartLocation(FVector::ZeroVector), OrthoZoom(DEFAULT_ORTHOZOOM)
{}

void FViewportCameraTransform::SetLocation(const FVector& Position)
{
    ViewLocation    = Position;
    DesiredLocation = ViewLocation;
}

void FViewportCameraTransform::TransitionToLocation(const FVector& InDesiredLocation, TWeakPtr<SWidget> EditorViewportWidget, bool bInstant)
{
    if (bInstant || !EditorViewportWidget.IsValid())
    {
        SetLocation(InDesiredLocation);
        TransitionCurve->JumpToEnd();
    }
    else
    {
        DesiredLocation = InDesiredLocation;
        StartLocation   = ViewLocation;

        TransitionCurve->Play(EditorViewportWidget.Pin().ToSharedRef());
    }
}

bool FViewportCameraTransform::UpdateTransition()
{
    bool bIsAnimating = false;
    if (TransitionCurve->IsPlaying() || ViewLocation != DesiredLocation)
    {
        float LerpWeight = TransitionCurve->GetLerp();

        if (LerpWeight == 1.0f)
        {
            // Failsafe for the value not being exact on lerps
            ViewLocation = DesiredLocation;
        }
        else
        {
            ViewLocation = FMath::Lerp(StartLocation, DesiredLocation, LerpWeight);
        }

        bIsAnimating = true;
    }

    return bIsAnimating;
}

FMatrix FViewportCameraTransform::ComputeOrbitMatrix() const
{
    FTransform Transform =
        FTransform(-LookAt) *
        FTransform(FRotator(0, ViewRotation.Yaw, 0)) *
        FTransform(FRotator(0, 0, ViewRotation.Pitch)) *
        FTransform(FVector(0, (ViewLocation - LookAt).Size(), 0));

    return Transform.ToMatrixNoScale() * FInverseRotationMatrix(FRotator(0, 90.f, 0));
}

bool FViewportCameraTransform::IsPlaying()
{
    return TransitionCurve->IsPlaying();
}

/**The Maximum Mouse/Camera Speeds Setting supported */
const uint32 FEditorViewportClient::MaxCameraSpeeds = 8;

float FEditorViewportClient::GetCameraSpeed() const
{
    return GetCameraSpeed(GetCameraSpeedSetting());
}

float FEditorViewportClient::GetCameraSpeed(int32 SpeedSetting) const
{
    // previous mouse speed values were as follows...
    //(note: these were previously all divided by 4 when used be the viewport)
    // #define MOVEMENTSPEED_SLOW			4	~ 1
    // #define MOVEMENTSPEED_NORMAL			12	~ 3
    // #define MOVEMENTSPEED_FAST			32	~ 8
    // #define MOVEMENTSPEED_VERYFAST		64	~ 16

    const int32 SpeedToUse = FMath::Clamp<int32>(SpeedSetting, 1, MaxCameraSpeeds);
    const float Speed[]    = {0.03125f, 0.09375f, 0.33f, 1.f, 3.f, 8.f, 16.f, 32.f};

    return Speed[SpeedToUse - 1];
}

void FEditorViewportClient::SetCameraSpeedSetting(int32 SpeedSetting)
{
    CameraSpeedSetting = SpeedSetting;
}

int32 FEditorViewportClient::GetCameraSpeedSetting() const
{
    return CameraSpeedSetting;
}

float FEditorViewportClient::GetCameraSpeedScalar() const
{
    return CameraSpeedScalar;
}

void FEditorViewportClient::SetCameraSpeedScalar(float SpeedScalar)
{
    CameraSpeedScalar = FMath::Clamp<float>(SpeedScalar, 1.0f, TNumericLimits<float>::Max());
}

float const FEditorViewportClient::SafePadding = 0.075f;

static int32 ViewOptionIndex                   = 0;
static TArray<ELevelViewportType> ViewOptions;

void InitViewOptionsArray()
{
    ViewOptions.Empty();

    ELevelViewportType Front  = ELevelViewportType::LVT_OrthoXZ;
    ELevelViewportType Back   = ELevelViewportType::LVT_OrthoNegativeXZ;
    ELevelViewportType Top    = ELevelViewportType::LVT_OrthoXY;
    ELevelViewportType Bottom = ELevelViewportType::LVT_OrthoNegativeXY;
    ELevelViewportType Left   = ELevelViewportType::LVT_OrthoYZ;
    ELevelViewportType Right  = ELevelViewportType::LVT_OrthoNegativeYZ;

    ViewOptions.Add(Front);
    ViewOptions.Add(Back);
    ViewOptions.Add(Top);
    ViewOptions.Add(Bottom);
    ViewOptions.Add(Left);
    ViewOptions.Add(Right);
}

FEditorViewportClient::FEditorViewportClient(FEditorModeTools* InModeTools, FPreviewScene* InPreviewScene, const TWeakPtr<SEditorViewport>& InEditorViewportWidget)
    : bAllowCinematicControl(false), CameraSpeedSetting(4), CameraSpeedScalar(1.0f), ImmersiveDelegate(), VisibilityDelegate(), Viewport(NULL), ViewportType(LVT_Perspective), ViewState(), StereoViewStates(), EngineShowFlags(ESFIM_Editor), LastEngineShowFlags(ESFIM_Game), ExposureSettings(), CurrentBufferVisualizationMode(NAME_None), CurrentRayTracingDebugVisualizationMode(NAME_None), FramesSinceLastDraw(0), ViewIndex(INDEX_NONE), ViewFOV(EditorViewportDefs::DefaultPerspectiveFOVAngle), FOVAngle(EditorViewportDefs::DefaultPerspectiveFOVAngle), AspectRatio(1.777777f), bForcingUnlitForNewMap(false), bWidgetAxisControlledByDrag(false), bNeedsRedraw(true), bNeedsLinkedRedraw(false), bNeedsInvalidateHitProxy(false), bUsingOrbitCamera(false), bUseNumpadCameraControl(true), bDisableInput(false), bDrawAxes(true), bSetListenerPosition(false), LandscapeLODOverride(-1), bDrawVertices(false), bShouldApplyViewModifiers(true), bOwnsModeTools(false), ModeTools(InModeTools), Widget(new FWidget), bShowWidget(true), MouseDeltaTracker(new FMouseDeltaTracker), RecordingInterpEd(NULL), bHasMouseMovedSinceClick(false), CameraController(new FEditorCameraController()), CameraUserImpulseData(new FCameraControllerUserImpulseData()), TimeForForceRedraw(0.0), FlightCameraSpeedScale(1.0f), bUseControllingActorViewInfo(false), LastMouseX(0), LastMouseY(0), CachedMouseX(0), CachedMouseY(0), CurrentMousePos(-1, -1), bIsTracking(false), bDraggingByHandle(false), CurrentGestureDragDelta(FVector::ZeroVector), CurrentGestureRotDelta(FRotator::ZeroRotator), GestureMoveForwardBackwardImpulse(0.0f), bForceAudioRealtime(false), RealTimeUntilFrameNumber(0), bIsRealtime(false), bShowStats(false), bHasAudioFocus(false), bShouldCheckHitProxy(false), bUsesDrawHelper(true), bIsSimulateInEditorViewport(false), bCameraLock(false), bIsCameraMoving(false), bIsCameraMovingOnTick(false), EditorViewportWidget(InEditorViewportWidget), PreviewScene(InPreviewScene), MovingPreviewLightSavedScreenPos(ForceInitToZero), MovingPreviewLightTimer(0.0f), bLockFlightCamera(false), PreviewResolutionFraction(1.0f), SceneDPIMode(ESceneDPIMode::EditorDefault), PerspViewModeIndex(DefaultPerspectiveViewMode), OrthoViewModeIndex(DefaultOrthoViewMode), ViewModeParam(-1), NearPlane(-1.0f), FarPlane(0.0f), bInGameViewMode(false), bInVREditViewMode(false), bShouldInvalidateViewportWidget(false), DragStartView(nullptr), DragStartViewFamily(nullptr)
{
    InitViewOptionsArray();
    if (ModeTools == nullptr)
    {
        ModeTools      = new FAssetEditorModeManager();
        bOwnsModeTools = true;
    }

    //@TODO: MODETOOLS: Would like to make this the default, and have specific editors opt-out, but for now opt-in is the safer choice
    // Widget->SetUsesEditorModeTools(ModeTools);

    ViewState.Allocate();

    // NOTE: StereoViewState will be allocated on demand, for viewports than end up drawing in stereo

    // add this client to list of views, and remember the index
    ViewIndex = GEditor->AddViewportClients(this);

    // Initialize the Cursor visibility struct
    RequiredCursorVisibiltyAndAppearance.bSoftwareCursorVisible = false;
    RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible = true;
    RequiredCursorVisibiltyAndAppearance.bDontResetCursor       = false;
    RequiredCursorVisibiltyAndAppearance.bOverrideAppearance    = false;
    RequiredCursorVisibiltyAndAppearance.RequiredCursor         = EMouseCursor::Default;

    // Setup defaults for the common draw helper.
    DrawHelper.bDrawPivot          = false;
    DrawHelper.bDrawWorldBox       = false;
    DrawHelper.bDrawKillZ          = false;
    DrawHelper.bDrawGrid           = false;  // disable this since we rely on the show flags
    DrawHelper.GridColorAxis       = FColor(160, 160, 160);
    DrawHelper.GridColorMajor      = FColor(144, 144, 144);
    DrawHelper.GridColorMinor      = FColor(128, 128, 128);
    DrawHelper.PerspectiveGridSize = EditorViewportClient::GridSize;
    DrawHelper.NumCells            = DrawHelper.PerspectiveGridSize / (EditorViewportClient::CellSize * 2);

    // Most editor viewports do not want motion blur.
    EngineShowFlags.MotionBlur = 0;

    EngineShowFlags.SetSnap(1);

    SetViewMode(IsPerspective() ? PerspViewModeIndex : OrthoViewModeIndex);

    ModeTools->OnEditorModeIDChanged().AddRaw(this, &FEditorViewportClient::OnEditorModeIDChanged);

    FCoreDelegates::StatCheckEnabled.AddRaw(this, &FEditorViewportClient::HandleViewportStatCheckEnabled);
    FCoreDelegates::StatEnabled.AddRaw(this, &FEditorViewportClient::HandleViewportStatEnabled);
    FCoreDelegates::StatDisabled.AddRaw(this, &FEditorViewportClient::HandleViewportStatDisabled);
    FCoreDelegates::StatDisableAll.AddRaw(this, &FEditorViewportClient::HandleViewportStatDisableAll);

    RequestUpdateDPIScale();

    FSlateApplication::Get().OnWindowDPIScaleChanged().AddRaw(this, &FEditorViewportClient::HandleWindowDPIScaleChanged);
}

FEditorViewportClient::~FEditorViewportClient()
{
    if (bOwnsModeTools)
    {
        ModeTools->SetDefaultMode(FBuiltinEditorModes::EM_Default);
        ModeTools->DeactivateAllModes();  // this also activates the default mode
    }

    ModeTools->OnEditorModeIDChanged().RemoveAll(this);

    delete Widget;
    delete MouseDeltaTracker;

    delete CameraController;
    CameraController = NULL;

    delete CameraUserImpulseData;
    CameraUserImpulseData = NULL;

    if (Viewport)
    {
        UE_LOG(LogEditorViewport, Fatal, TEXT("Viewport != NULL in FEditorViewportClient destructor."));
    }

    if (GEditor)
    {
        GEditor->RemoveViewportClients(this);
    }

    FCoreDelegates::StatCheckEnabled.RemoveAll(this);
    FCoreDelegates::StatEnabled.RemoveAll(this);
    FCoreDelegates::StatDisabled.RemoveAll(this);
    FCoreDelegates::StatDisableAll.RemoveAll(this);

    if (FSlateApplication::IsInitialized())
    {
        FSlateApplication::Get().OnWindowDPIScaleChanged().RemoveAll(this);
    }

    if (bOwnsModeTools)
    {
        delete ModeTools;
        ModeTools = nullptr;
    }
}

void FEditorViewportClient::AddRealtimeOverride(bool bShouldBeRealtime, FText SystemDisplayName)
{
    RealtimeOverrides.Add(TPair<bool, FText>(bShouldBeRealtime, SystemDisplayName));

    bShouldInvalidateViewportWidget = true;
}

bool FEditorViewportClient::HasRealtimeOverride(FText SystemDisplayName) const
{
    for (int32 Index = 0; Index < RealtimeOverrides.Num(); ++Index)
    {
        if (RealtimeOverrides[Index].Value.EqualTo(SystemDisplayName))
        {
            return true;
        }
    }
    return false;
}

bool FEditorViewportClient::RemoveRealtimeOverride(FText SystemDisplayName, bool bCheckMissingOverride)
{
    bool bRemoved = false;
    for (int32 Index = RealtimeOverrides.Num() - 1; Index >= 0; --Index)
    {
        if (RealtimeOverrides[Index].Value.EqualTo(SystemDisplayName))
        {
            RealtimeOverrides.RemoveAt(Index);
            bRemoved = true;
            break;
        }
    }
    check(!bCheckMissingOverride || bRemoved);

    if (bRemoved)
    {
        bShouldInvalidateViewportWidget = true;
    }

    return bRemoved;
}

bool FEditorViewportClient::PopRealtimeOverride()
{
    if (RealtimeOverrides.Num() > 0)
    {
        RealtimeOverrides.Pop();

        bShouldInvalidateViewportWidget = true;

        return true;
    }

    return false;
}

bool FEditorViewportClient::ToggleRealtime()
{
    SetRealtime(!bIsRealtime);
    return bIsRealtime;
}

void FEditorViewportClient::SetRealtime(bool bInRealtime)
{
    bIsRealtime                     = bInRealtime;
    bShouldInvalidateViewportWidget = true;
}

FText FEditorViewportClient::GetRealtimeOverrideMessage() const
{
    return RealtimeOverrides.Num() > 0 ? RealtimeOverrides.Last().Value : FText::GetEmpty();
}

void FEditorViewportClient::SetRealtime(bool bInRealtime, bool bStoreCurrentValue)
{
    SetRealtime(bInRealtime);
}

void FEditorViewportClient::RestoreRealtime(const bool bAllowDisable)
{
    PopRealtimeOverride();
}

void FEditorViewportClient::SaveRealtimeStateToConfig(bool& ConfigVar) const
{
    // Note, this should not ever look at anything but the true realtime state.  No overrides etc.
    ConfigVar = bIsRealtime;
}

void FEditorViewportClient::SetShowStats(bool bWantStats)
{
    bShowStats = bWantStats;
}

void FEditorViewportClient::InvalidateViewportWidget()
{
    if (EditorViewportWidget.IsValid())
    {
        // Invalidate the viewport widget to register its active timer
        EditorViewportWidget.Pin()->Invalidate();
    }
    bShouldInvalidateViewportWidget = false;
}

void FEditorViewportClient::RedrawRequested(FViewport* InViewport)
{
    bNeedsRedraw = true;
}

void FEditorViewportClient::RequestInvalidateHitProxy(FViewport* InViewport)
{
    bNeedsInvalidateHitProxy = true;
}

void FEditorViewportClient::OnEditorModeChanged(FEdMode* EditorMode, bool bIsEntering)
{
    if (Viewport)
    {
        RequestInvalidateHitProxy(Viewport);
    }
}

void FEditorViewportClient::OnEditorModeIDChanged(const FEditorModeID& EditorModeID, bool bIsEntering)
{
    if (Viewport)
    {
        RequestInvalidateHitProxy(Viewport);
    }
}

float FEditorViewportClient::GetOrthoUnitsPerPixel(const FViewport* InViewport) const
{
    const float SizeX = InViewport->GetSizeXY().X;

    // 15.0f was coming from the CAMERA_ZOOM_DIV marco, seems it was chosen arbitrarily
    return (GetOrthoZoom() / (SizeX * 15.f)) * ComputeOrthoZoomFactor(SizeX);
}

void FEditorViewportClient::SetViewLocationForOrbiting(const FVector& LookAtPoint, float DistanceToCamera)
{
    FMatrix Matrix    = FTranslationMatrix(-GetViewLocation());
    Matrix            = Matrix * FInverseRotationMatrix(GetViewRotation());
    FMatrix CamRotMat = Matrix.InverseFast();
    FVector CamDir    = FVector(CamRotMat.M[0][0], CamRotMat.M[0][1], CamRotMat.M[0][2]);
    SetViewLocation(LookAtPoint - DistanceToCamera * CamDir);
    SetLookAtLocation(LookAtPoint);
}

void FEditorViewportClient::SetInitialViewTransform(ELevelViewportType InViewportType, const FVector& ViewLocation, const FRotator& ViewRotation, float InOrthoZoom)
{
    check(InViewportType < LVT_MAX);

    FViewportCameraTransform& ViewTransform = (InViewportType == LVT_Perspective) ? ViewTransformPerspective : ViewTransformOrthographic;

    ViewTransform.SetLocation(ViewLocation);
    ViewTransform.SetRotation(ViewRotation);

    // Make a look at location in front of the camera
    const FQuat CameraOrientation = FQuat::MakeFromEuler(ViewRotation.Euler());
    FVector Direction             = CameraOrientation.RotateVector(FVector(1, 0, 0));

    ViewTransform.SetLookAt(ViewLocation + Direction * OrbitConstants::IntialLookAtDistance);
    ViewTransform.SetOrthoZoom(InOrthoZoom);
}

void FEditorViewportClient::ToggleOrbitCamera(bool bEnableOrbitCamera)
{
    if (bUsingOrbitCamera != bEnableOrbitCamera)
    {
        FViewportCameraTransform& ViewTransform = GetViewTransform();

        bUsingOrbitCamera                       = bEnableOrbitCamera;

        // Convert orbit view to regular view
        FMatrix OrbitMatrix = ViewTransform.ComputeOrbitMatrix();
        OrbitMatrix         = OrbitMatrix.InverseFast();

        if (!bUsingOrbitCamera)
        {
            // Ensure that the view location and rotation is up to date to ensure smooth transition in and out of orbit mode
            ViewTransform.SetRotation(OrbitMatrix.Rotator());
        }
        else
        {
            FRotator ViewRotation = ViewTransform.GetRotation();

            bool bUpsideDown      = (ViewRotation.Pitch < -90.0f || ViewRotation.Pitch > 90.0f || !FMath::IsNearlyZero(ViewRotation.Roll, KINDA_SMALL_NUMBER));

            // if the camera is upside down compute the rotation differently to preserve pitch
            // otherwise the view will pop to right side up when transferring to orbit controls
            if (bUpsideDown)
            {
                FMatrix OrbitViewMatrix = FTranslationMatrix(-ViewTransform.GetLocation());
                OrbitViewMatrix *= FInverseRotationMatrix(ViewRotation);
                OrbitViewMatrix *= FRotationMatrix(FRotator(0, 90.f, 0));

                FMatrix RotMat     = FTranslationMatrix(-ViewTransform.GetLookAt()) * OrbitViewMatrix;
                FMatrix RotMatInv  = RotMat.InverseFast();
                FRotator RollVec   = RotMatInv.Rotator();
                FMatrix YawMat     = RotMatInv * FInverseRotationMatrix(FRotator(0, 0, -RollVec.Roll));
                FMatrix YawMatInv  = YawMat.InverseFast();
                FRotator YawVec    = YawMat.Rotator();
                FRotator rotYawInv = YawMatInv.Rotator();
                ViewTransform.SetRotation(FRotator(-RollVec.Roll, YawVec.Yaw, 0));
            }
            else
            {
                ViewTransform.SetRotation(OrbitMatrix.Rotator());
            }
        }

        ViewTransform.SetLocation(OrbitMatrix.GetOrigin());
    }
}

void FEditorViewportClient::FocusViewportOnBox(const FBox& BoundingBox, bool bInstant /* = false */)
{
    const FVector Position = BoundingBox.GetCenter();
    float Radius           = FMath::Max(BoundingBox.GetExtent().Size(), 10.f);

    float AspectToUse      = AspectRatio;
    FIntPoint ViewportSize = Viewport->GetSizeXY();
    if (!bUseControllingActorViewInfo && ViewportSize.X > 0 && ViewportSize.Y > 0)
    {
        AspectToUse = Viewport->GetDesiredAspectRatio();
    }

    const bool bEnable = false;
    ToggleOrbitCamera(bEnable);

    {
        FViewportCameraTransform& ViewTransform = GetViewTransform();

        if (!IsOrtho())
        {
            /**
             * We need to make sure we are fitting the sphere into the viewport completely, so if the height of the viewport is less
             * than the width of the viewport, we scale the radius by the aspect ratio in order to compensate for the fact that we have
             * less visible vertically than horizontally.
             */
            if (AspectToUse > 1.0f)
            {
                Radius *= AspectToUse;
            }

            /**
             * Now that we have a adjusted radius, we are taking half of the viewport's FOV,
             * converting it to radians, and then figuring out the camera's distance from the center
             * of the bounding sphere using some simple trig.  Once we have the distance, we back up
             * along the camera's forward vector from the center of the sphere, and set our new view location.
             */

            const float HalfFOVRadians     = FMath::DegreesToRadians(ViewFOV / 2.0f);
            const float DistanceFromSphere = Radius / FMath::Tan(HalfFOVRadians);
            FVector CameraOffsetVector     = ViewTransform.GetRotation().Vector() * -DistanceFromSphere;

            ViewTransform.SetLookAt(Position);
            ViewTransform.TransitionToLocation(Position + CameraOffsetVector, EditorViewportWidget, bInstant);
        }
        else
        {
            // For ortho viewports just set the camera position to the center of the bounding volume.
            // SetViewLocation( Position );
            ViewTransform.TransitionToLocation(Position, EditorViewportWidget, bInstant);

            if (!(Viewport->KeyState(EKeys::LeftControl) || Viewport->KeyState(EKeys::RightControl)))
            {
                /**
                 * We also need to zoom out till the entire volume is in view.  The following block of code first finds the minimum dimension
                 * size of the viewport.  It then calculates backwards from what the view size should be (The radius of the bounding volume),
                 * to find the new OrthoZoom value for the viewport. The 15.0f is a fudge factor.
                 */
                float NewOrthoZoom;
                uint32 MinAxisSize = (AspectToUse > 1.0f) ? Viewport->GetSizeXY().Y : Viewport->GetSizeXY().X;
                float Zoom         = Radius / (MinAxisSize / 2.0f);

                NewOrthoZoom       = Zoom * (Viewport->GetSizeXY().X * 15.0f);
                NewOrthoZoom       = FMath::Clamp<float>(NewOrthoZoom, GetMinimumOrthoZoom(), MAX_ORTHOZOOM);
                ViewTransform.SetOrthoZoom(NewOrthoZoom);
            }
        }
    }

    // Tell the viewport to redraw itself.
    Invalidate();
}

void FEditorViewportClient::CenterViewportAtPoint(const FVector& NewLookAt, bool bInstant /* = false */)
{
    const bool bEnable = false;
    ToggleOrbitCamera(bEnable);

    FViewportCameraTransform& ViewTransform = GetViewTransform();
    FQuat Rotation(ViewTransform.GetRotation());
    FVector LookatVec = ViewTransform.GetLookAt() - ViewTransform.GetLocation();
    // project current lookat vector onto forward vector to get lookat distance, new position is that far along forward vector
    double LookatDist   = FVector::DotProduct(Rotation.GetForwardVector(), LookatVec);
    FVector NewLocation = NewLookAt - LookatDist * Rotation.GetForwardVector();

    // ortho and perspective are treated the same here
    ViewTransform.SetLookAt(NewLookAt);
    ViewTransform.TransitionToLocation(NewLocation, EditorViewportWidget, bInstant);

    // Tell the viewport to redraw itself.
    Invalidate();
}

//////////////////////////////////////////////////////////////////////////
//
// Configures the specified FSceneView object with the view and projection matrices for this viewport.

FSceneView* FEditorViewportClient::CalcSceneView(FSceneViewFamily* ViewFamily, const EStereoscopicPass StereoPass)
{
    const bool bStereoRendering = StereoPass != eSSP_FULL;

    FSceneViewInitOptions ViewInitOptions;

    FViewportCameraTransform& ViewTransform        = GetViewTransform();
    const ELevelViewportType EffectiveViewportType = GetViewportType();

    // Apply view modifiers.
    FEditorViewportViewModifierParams ViewModifierParams;
    {
        ViewModifierParams.ViewInfo.Location = ViewTransform.GetLocation();
        ViewModifierParams.ViewInfo.Rotation = ViewTransform.GetRotation();

        if (bUseControllingActorViewInfo)
        {
            ViewModifierParams.ViewInfo.FOV = ControllingActorViewInfo.FOV;
        }
        else
        {
            ViewModifierParams.ViewInfo.FOV = ViewFOV;
        }

        if (bShouldApplyViewModifiers)
        {
            ViewModifiers.Broadcast(ViewModifierParams);
        }
    }
    const FVector ModifiedViewLocation = ViewModifierParams.ViewInfo.Location;
    FRotator ModifiedViewRotation      = ViewModifierParams.ViewInfo.Rotation;
    const float ModifiedViewFOV        = ViewModifierParams.ViewInfo.FOV;
    if (bUseControllingActorViewInfo)
    {
        ControllingActorViewInfo.Location = ViewModifierParams.ViewInfo.Location;
        ControllingActorViewInfo.Rotation = ViewModifierParams.ViewInfo.Rotation;
        ControllingActorViewInfo.FOV      = ViewModifierParams.ViewInfo.FOV;
    }

    ViewInitOptions.ViewOrigin = ModifiedViewLocation;

    // Apply head tracking!  Note that this won't affect what the editor *thinks* the view location and rotation is, it will
    // only affect the rendering of the scene.
    if (bStereoRendering && GEngine->XRSystem.IsValid() && GEngine->XRSystem->IsHeadTrackingAllowed())
    {
        FQuat CurrentHmdOrientation;
        FVector CurrentHmdPosition;
        GEngine->XRSystem->GetCurrentPose(IXRTrackingSystem::HMDDeviceId, CurrentHmdOrientation, CurrentHmdPosition);

        const FQuat VisualRotation = ModifiedViewRotation.Quaternion() * CurrentHmdOrientation;
        ModifiedViewRotation       = VisualRotation.Rotator();
        ModifiedViewRotation.Normalize();
    }

    FIntPoint ViewportSize = Viewport->GetSizeXY();
    FIntPoint ViewportOffset(0, 0);

    // We expect some size to avoid problems with the view rect manipulation
    if (ViewportSize.X > 50 && ViewportSize.Y > 50)
    {
        int32 Value = CVarEditorViewportTest.GetValueOnGameThread();

        if (Value)
        {
            int InsetX = ViewportSize.X / 4;
            int InsetY = ViewportSize.Y / 4;

            // this allows to test various typical view port situations
            switch (Value)
            {
                case 1:
                    ViewportOffset.X += InsetX;
                    ViewportOffset.Y += InsetY;
                    ViewportSize.X -= InsetX * 2;
                    ViewportSize.Y -= InsetY * 2;
                    break;
                case 2:
                    ViewportOffset.Y += InsetY;
                    ViewportSize.Y -= InsetY * 2;
                    break;
                case 3:
                    ViewportOffset.X += InsetX;
                    ViewportSize.X -= InsetX * 2;
                    break;
                case 4:
                    ViewportSize.X /= 2;
                    ViewportSize.Y /= 2;
                    break;
                case 5:
                    ViewportSize.X /= 2;
                    ViewportSize.Y /= 2;
                    ViewportOffset.X += ViewportSize.X;
                    break;
                case 6:
                    ViewportSize.X /= 2;
                    ViewportSize.Y /= 2;
                    ViewportOffset.Y += ViewportSize.Y;
                    break;
                case 7:
                    ViewportSize.X /= 2;
                    ViewportSize.Y /= 2;
                    ViewportOffset.X += ViewportSize.X;
                    ViewportOffset.Y += ViewportSize.Y;
                    break;
            }
        }
    }

    ViewInitOptions.SetViewRectangle(FIntRect(ViewportOffset, ViewportOffset + ViewportSize));

    // no matter how we are drawn (forced or otherwise), reset our time here
    TimeForForceRedraw                                   = 0.0;

    const bool bConstrainAspectRatio                     = bUseControllingActorViewInfo && ControllingActorViewInfo.bConstrainAspectRatio;
    EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULevelEditorViewportSettings>()->AspectRatioAxisConstraint;
    if (bUseControllingActorViewInfo && ControllingActorAspectRatioAxisConstraint.IsSet())
    {
        AspectRatioAxisConstraint = ControllingActorAspectRatioAxisConstraint.GetValue();
    }

    AWorldSettings* WorldSettings = nullptr;
    if (GetScene() != nullptr && GetScene()->GetWorld() != nullptr)
    {
        WorldSettings = GetScene()->GetWorld()->GetWorldSettings();
    }
    if (WorldSettings != nullptr)
    {
        ViewInitOptions.WorldToMetersScale = WorldSettings->WorldToMeters;
    }

    if (bUseControllingActorViewInfo)
    {
        // @todo vreditor: Not stereo friendly yet
        ViewInitOptions.ViewRotationMatrix = FInverseRotationMatrix(ModifiedViewRotation) * FMatrix(
                                                                                                FPlane(0, 0, 1, 0),
                                                                                                FPlane(1, 0, 0, 0),
                                                                                                FPlane(0, 1, 0, 0),
                                                                                                FPlane(0, 0, 0, 1));

        FMinimalViewInfo::CalculateProjectionMatrixGivenView(ControllingActorViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ViewInitOptions);
    }
    else
    {
        //
        if (EffectiveViewportType == LVT_Perspective)
        {
            // If stereo rendering is enabled, update the size and offset appropriately for this pass
            // @todo vreditor: Also need to update certain other use cases of ViewFOV like culling, streaming, etc.  (needs accessor)
            if (bStereoRendering)
            {
                int32 X      = 0;
                int32 Y      = 0;
                uint32 SizeX = ViewportSize.X;
                uint32 SizeY = ViewportSize.Y;
                GEngine->StereoRenderingDevice->AdjustViewRect(StereoPass, X, Y, SizeX, SizeY);
                const FIntRect StereoViewRect = FIntRect(X, Y, X + SizeX, Y + SizeY);
                ViewInitOptions.SetViewRectangle(StereoViewRect);

                GEngine->StereoRenderingDevice->CalculateStereoViewOffset(StereoPass, ModifiedViewRotation, ViewInitOptions.WorldToMetersScale, ViewInitOptions.ViewOrigin);
            }

            // Calc view rotation matrix
            ViewInitOptions.ViewRotationMatrix = CalcViewRotationMatrix(ModifiedViewRotation);

            // Rotate view 90 degrees
            ViewInitOptions.ViewRotationMatrix = ViewInitOptions.ViewRotationMatrix * FMatrix(
                                                                                          FPlane(0, 0, 1, 0),
                                                                                          FPlane(1, 0, 0, 0),
                                                                                          FPlane(0, 1, 0, 0),
                                                                                          FPlane(0, 0, 0, 1));

            if (bStereoRendering)
            {
                // @todo vreditor: bConstrainAspectRatio is ignored in this path, as it is in the game client as well currently
                // Let the stereoscopic rendering device handle creating its own projection matrix, as needed
                ViewInitOptions.ProjectionMatrix = GEngine->StereoRenderingDevice->GetStereoProjectionMatrix(StereoPass);
            }
            else
            {
                const float MinZ = GetNearClipPlane();
                const float MaxZ = MinZ;
                // Avoid zero ViewFOV's which cause divide by zero's in projection matrix
                const float MatrixFOV = FMath::Max(0.001f, ModifiedViewFOV) * (float)PI / 360.0f;

                if (bConstrainAspectRatio)
                {
                    if ((bool)ERHIZBuffer::IsInverted)
                    {
                        ViewInitOptions.ProjectionMatrix = FReversedZPerspectiveMatrix(
                            MatrixFOV,
                            MatrixFOV,
                            1.0f,
                            AspectRatio,
                            MinZ,
                            MaxZ);
                    }
                    else
                    {
                        ViewInitOptions.ProjectionMatrix = FPerspectiveMatrix(
                            MatrixFOV,
                            MatrixFOV,
                            1.0f,
                            AspectRatio,
                            MinZ,
                            MaxZ);
                    }
                }
                else
                {
                    float XAxisMultiplier;
                    float YAxisMultiplier;

                    if (((ViewportSize.X > ViewportSize.Y) && (AspectRatioAxisConstraint == AspectRatio_MajorAxisFOV)) || (AspectRatioAxisConstraint == AspectRatio_MaintainXFOV))
                    {
                        // if the viewport is wider than it is tall
                        XAxisMultiplier = 1.0f;
                        YAxisMultiplier = ViewportSize.X / (float)ViewportSize.Y;
                    }
                    else
                    {
                        // if the viewport is taller than it is wide
                        XAxisMultiplier = ViewportSize.Y / (float)ViewportSize.X;
                        YAxisMultiplier = 1.0f;
                    }

                    if ((bool)ERHIZBuffer::IsInverted)
                    {
                        ViewInitOptions.ProjectionMatrix = FReversedZPerspectiveMatrix(
                            MatrixFOV,
                            MatrixFOV,
                            XAxisMultiplier,
                            YAxisMultiplier,
                            MinZ,
                            MaxZ);
                    }
                    else
                    {
                        ViewInitOptions.ProjectionMatrix = FPerspectiveMatrix(
                            MatrixFOV,
                            MatrixFOV,
                            XAxisMultiplier,
                            YAxisMultiplier,
                            MinZ,
                            MaxZ);
                    }
                }
            }
        }
        else
        {
            static_assert((bool)ERHIZBuffer::IsInverted, "Check all the Rotation Matrix transformations!");
            float ZScale  = 0.5f / HALF_WORLD_MAX;
            float ZOffset = HALF_WORLD_MAX;

            // The divisor for the matrix needs to match the translation code.
            const float Zoom  = GetOrthoUnitsPerPixel(Viewport);

            float OrthoWidth  = Zoom * ViewportSize.X / 2.0f;
            float OrthoHeight = Zoom * ViewportSize.Y / 2.0f;

            if (EffectiveViewportType == LVT_OrthoXY)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(1, 0, 0, 0),
                    FPlane(0, -1, 0, 0),
                    FPlane(0, 0, -1, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoXZ)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(1, 0, 0, 0),
                    FPlane(0, 0, -1, 0),
                    FPlane(0, 1, 0, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoYZ)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(0, 0, 1, 0),
                    FPlane(1, 0, 0, 0),
                    FPlane(0, 1, 0, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoNegativeXY)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(-1, 0, 0, 0),
                    FPlane(0, -1, 0, 0),
                    FPlane(0, 0, 1, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoNegativeXZ)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(-1, 0, 0, 0),
                    FPlane(0, 0, 1, 0),
                    FPlane(0, 1, 0, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoNegativeYZ)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(0, 0, -1, 0),
                    FPlane(-1, 0, 0, 0),
                    FPlane(0, 1, 0, 0),
                    FPlane(0, 0, 0, 1));
            }
            else if (EffectiveViewportType == LVT_OrthoFreelook)
            {
                ViewInitOptions.ViewRotationMatrix = FMatrix(
                    FPlane(0, 0, 1, 0),
                    FPlane(1, 0, 0, 0),
                    FPlane(0, 1, 0, 0),
                    FPlane(0, 0, 0, 1));
            }
            else
            {
                // Unknown viewport type
                check(false);
            }

            ViewInitOptions.ProjectionMatrix = FReversedZOrthoMatrix(
                OrthoWidth,
                OrthoHeight,
                ZScale,
                ZOffset);
        }

        if (bConstrainAspectRatio)
        {
            ViewInitOptions.SetConstrainedViewRectangle(Viewport->CalculateViewExtents(AspectRatio, ViewInitOptions.GetViewRect()));
        }
    }

    if (!ViewInitOptions.IsValidViewRectangle())
    {
        // Zero sized rects are invalid, so fake to 1x1 to avoid asserts later on
        ViewInitOptions.SetViewRectangle(FIntRect(0, 0, 1, 1));
    }

    // Allocate our stereo view state on demand, so that only viewports that actually use stereo features have one
    const int32 ViewStateIndex = (StereoPass > eSSP_RIGHT_EYE) ? StereoPass - eSSP_RIGHT_EYE : 0;
    if (bStereoRendering)
    {
        if (StereoViewStates.Num() <= ViewStateIndex)
        {
            StereoViewStates.SetNum(ViewStateIndex + 1);
        }

        if (StereoViewStates[ViewStateIndex].GetReference() == nullptr)
        {
            StereoViewStates[ViewStateIndex].Allocate();
        }
    }

    ViewInitOptions.ViewFamily              = ViewFamily;
    ViewInitOptions.SceneViewStateInterface = ((StereoPass < eSSP_RIGHT_EYE) ? ViewState.GetReference() : StereoViewStates[ViewStateIndex].GetReference());
    ViewInitOptions.StereoPass              = StereoPass;

    ViewInitOptions.ViewElementDrawer       = this;

    ViewInitOptions.BackgroundColor         = GetBackgroundColor();

    ViewInitOptions.EditorViewBitflag       = (uint64)1 << ViewIndex,  // send the bit for this view - each actor will check it's visibility bits against this

        // for ortho views to steal perspective view origin
        ViewInitOptions.OverrideLODViewOrigin = FVector::ZeroVector;
    ViewInitOptions.bUseFauxOrthoViewPos      = true;

    ViewInitOptions.FOV                       = ModifiedViewFOV;
    if (bUseControllingActorViewInfo)
    {
        ViewInitOptions.bUseFieldOfViewForLOD = ControllingActorViewInfo.bUseFieldOfViewForLOD;
        ViewInitOptions.FOV                   = ControllingActorViewInfo.FOV;
    }

    ViewInitOptions.OverrideFarClippingPlaneDistance = FarPlane;
    ViewInitOptions.CursorPos                        = CurrentMousePos;

    FSceneView* View                                 = new FSceneView(ViewInitOptions);

    View->ViewLocation                               = ModifiedViewLocation;
    View->ViewRotation                               = ModifiedViewRotation;
    View->PlayerLocation                             = ModifiedViewLocation;

    View->SubduedSelectionOutlineColor               = GEngine->GetSubduedSelectionOutlineColor();

    ViewFamily->Views.Add(View);

    View->StartFinalPostprocessSettings(View->ViewLocation);

    if (bUseControllingActorViewInfo)
    {
        // Pass on the previous view transform of the controlling actor to the view
        View->PreviousViewTransform = ControllingActorViewInfo.PreviousViewTransform;
        View->OverridePostProcessSettings(ControllingActorViewInfo.PostProcessSettings, ControllingActorViewInfo.PostProcessBlendWeight);

        for (int32 ExtraPPBlendIdx = 0; ExtraPPBlendIdx < ControllingActorExtraPostProcessBlends.Num(); ++ExtraPPBlendIdx)
        {
            FPostProcessSettings const& PPSettings = ControllingActorExtraPostProcessBlends[ExtraPPBlendIdx];
            float const Weight                     = ControllingActorExtraPostProcessBlendWeights[ExtraPPBlendIdx];
            View->OverridePostProcessSettings(PPSettings, Weight);
        }
    }
    else
    {
        OverridePostProcessSettings(*View);
    }

    if (ViewModifierParams.ViewInfo.PostProcessBlendWeight > 0.f)
    {
        View->OverridePostProcessSettings(ViewModifierParams.ViewInfo.PostProcessSettings, ViewModifierParams.ViewInfo.PostProcessBlendWeight);
    }
    const int32 PPNum = FMath::Min(ViewModifierParams.PostProcessSettings.Num(), ViewModifierParams.PostProcessBlendWeights.Num());
    for (int32 PPIndex = 0; PPIndex < PPNum; ++PPIndex)
    {
        const FPostProcessSettings& PPSettings = ViewModifierParams.PostProcessSettings[PPIndex];
        const float PPWeight                   = ViewModifierParams.PostProcessBlendWeights[PPIndex];
        View->OverridePostProcessSettings(PPSettings, PPWeight);
    }

    View->EndFinalPostprocessSettings(ViewInitOptions);

    for (int ViewExt = 0; ViewExt < ViewFamily->ViewExtensions.Num(); ViewExt++)
    {
        ViewFamily->ViewExtensions[ViewExt]->SetupView(*ViewFamily, *View);
    }

    return View;
}

/** Determines if the new MoveCanvas movement should be used
 * @return - true if we should use the new drag canvas movement.  Returns false for combined object-camera movement and marquee selection
 */
bool FLevelEditorViewportClient::ShouldUseMoveCanvasMovement()
{
    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) ? true : false;
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton) ? true : false;
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton) ? true : false;
    const bool bMouseButtonDown      = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);

    const bool AltDown               = IsAltPressed();
    const bool ShiftDown             = IsShiftPressed();
    const bool ControlDown           = IsCtrlPressed();

    // if we're using the new move canvas mode, we're in an ortho viewport, and the mouse is down
    if (GetDefault<ULevelEditorViewportSettings>()->bPanMovesCanvas && IsOrtho() && bMouseButtonDown)
    {
        // MOVING CAMERA
        if (!MouseDeltaTracker->UsingDragTool() && AltDown == false && ShiftDown == false && ControlDown == false && (Widget->GetCurrentAxis() == EAxisList::None) && (LeftMouseButtonDown ^ RightMouseButtonDown))
        {
            return true;
        }

        // OBJECT MOVEMENT CODE
        if ((AltDown == false && ShiftDown == false && (LeftMouseButtonDown ^ RightMouseButtonDown)) &&
            ((GetWidgetMode() == FWidget::WM_Translate && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_TranslateRotateZ && Widget->GetCurrentAxis() != EAxisList::ZRotation && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_2D && Widget->GetCurrentAxis() != EAxisList::Rotate2D && Widget->GetCurrentAxis() != EAxisList::None)))
        {
            return true;
        }

        // ALL other cases hide the mouse
        return false;
    }
    else
    {
        // current system - do not show cursor when mouse is down
        return false;
    }
}

void FEditorViewportClient::ReceivedFocus(FViewport* InViewport)
{
    // Viewport has changed got to reset the cursor as it could of been left in any state
    UpdateRequiredCursorVisibility();
    ApplyRequiredCursorVisibility(true);

    // Force a cursor update to make sure its returned to default as it could of been left in any state and wont update itself till an action is taken
    SetRequiredCursorOverride(false, EMouseCursor::Default);
    FSlateApplication::Get().QueryCursor();

    if (IsMatineeRecordingWindow())
    {
        // Allow the joystick to be used for matinee capture
        InViewport->SetUserFocus(true);
    }

    ModeTools->ReceivedFocus(this, Viewport);
}

void FEditorViewportClient::LostFocus(FViewport* InViewport)
{
    StopTracking();
    ModeTools->LostFocus(this, Viewport);
}

void FEditorViewportClient::Tick(float DeltaTime)
{
    ConditionalCheckHoveredHitProxy();

    FViewportCameraTransform& ViewTransform = GetViewTransform();
    const bool bIsAnimating                 = ViewTransform.UpdateTransition();
    if (bIsAnimating && GetViewportType() == LVT_Perspective)
    {
        PerspectiveCameraMoved();
    }

    if (bIsTracking)
    {
        FEditorViewportStats::BeginFrame();
    }

    if (!bIsAnimating)
    {
        bIsCameraMovingOnTick = bIsCameraMoving;

        // Update any real-time camera movement
        UpdateCameraMovement(DeltaTime);

        UpdateMouseDelta();

        UpdateGestureDelta();

        EndCameraMovement();
    }

    const bool bStereoRendering = GEngine->XRSystem.IsValid() && GEngine->IsStereoscopic3D(Viewport);
    if (bStereoRendering)
    {
        // Every frame, we'll push our camera position to the HMD device, so that it can properly compute a head-relative offset for each eye
        if (GEngine->XRSystem->IsHeadTrackingAllowed())
        {
            auto XRCamera = GEngine->XRSystem->GetXRCamera();
            if (XRCamera.IsValid())
            {
                FQuat PlayerOrientation = GetViewRotation().Quaternion();
                FVector PlayerLocation  = GetViewLocation();
                XRCamera->UseImplicitHMDPosition(false);
                XRCamera->UpdatePlayerCamera(PlayerOrientation, PlayerLocation);
            }
        }
    }

    if (bIsTracking)
    {
        // If a mouse button or modifier is pressed we want to assume the user is still in a mode
        // they haven't left to perform a non-action in the frame to keep the last used operation
        // from being reset.
        const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) ? true : false;
        const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton) ? true : false;
        const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton) ? true : false;
        const bool bMouseButtonDown      = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);

        const bool AltDown               = IsAltPressed();
        const bool ShiftDown             = IsShiftPressed();
        const bool ControlDown           = IsCtrlPressed();
        const bool bModifierDown         = AltDown || ShiftDown || ControlDown;
        if (bMouseButtonDown || bModifierDown)
        {
            FEditorViewportStats::NoOpUsing();
        }

        FEditorViewportStats::EndFrame();
    }

    // refresh ourselves if animating or told to from another view
    if (bIsAnimating || (TimeForForceRedraw != 0.0 && FPlatformTime::Seconds() > TimeForForceRedraw))
    {
        Invalidate();
    }

    // Update the fade out animation
    if (MovingPreviewLightTimer > 0.0f)
    {
        MovingPreviewLightTimer = FMath::Max(MovingPreviewLightTimer - DeltaTime, 0.0f);

        if (MovingPreviewLightTimer == 0.0f)
        {
            Invalidate();
        }
    }

    // Invalidate the viewport widget if pending
    if (bShouldInvalidateViewportWidget)
    {
        InvalidateViewportWidget();
    }

    // Tick the editor modes
    ModeTools->Tick(this, DeltaTime);
}

namespace ViewportDeadZoneConstants
{
enum
{
    NO_DEAD_ZONE,
    STANDARD_DEAD_ZONE
};
};  // namespace ViewportDeadZoneConstants

float GetFilteredDelta(const float DefaultDelta, const uint32 DeadZoneType, const float StandardDeadZoneSize)
{
    if (DeadZoneType == ViewportDeadZoneConstants::NO_DEAD_ZONE)
    {
        return DefaultDelta;
    }
    else
    {
        // can't be one or normalizing won't work
        check(FMath::IsWithin<float>(StandardDeadZoneSize, 0.0f, 1.0f));
        // standard dead zone
        float ClampedAbsValue           = FMath::Clamp(FMath::Abs(DefaultDelta), StandardDeadZoneSize, 1.0f);
        float NormalizedClampedAbsValue = (ClampedAbsValue - StandardDeadZoneSize) / (1.0f - StandardDeadZoneSize);
        float ClampedSignedValue        = (DefaultDelta >= 0.0f) ? NormalizedClampedAbsValue : -NormalizedClampedAbsValue;
        return ClampedSignedValue;
    }
}

/**Applies Joystick axis control to camera movement*/
void FEditorViewportClient::UpdateCameraMovementFromJoystick(const bool bRelativeMovement, FCameraControllerConfig& InConfig)
{
    for (TMap<int32, FCachedJoystickState*>::TConstIterator JoystickIt(JoystickStateMap); JoystickIt; ++JoystickIt)
    {
        FCachedJoystickState* JoystickState = JoystickIt.Value();
        check(JoystickState);
        for (TMap<FKey, float>::TConstIterator AxisIt(JoystickState->AxisDeltaValues); AxisIt; ++AxisIt)
        {
            FKey Key                     = AxisIt.Key();
            float UnfilteredDelta        = AxisIt.Value();
            const float StandardDeadZone = CameraController->GetConfig().ImpulseDeadZoneAmount;

            if (bRelativeMovement)
            {
                // XBOX Controller
                if (Key == EKeys::Gamepad_LeftX)
                {
                    CameraUserImpulseData->MoveRightLeftImpulse += GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.TranslationMultiplier;
                }
                else if (Key == EKeys::Gamepad_LeftY)
                {
                    CameraUserImpulseData->MoveForwardBackwardImpulse += GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.TranslationMultiplier;
                }
                else if (Key == EKeys::Gamepad_RightX)
                {
                    float DeltaYawImpulse = GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.RotationMultiplier * (InConfig.bInvertX ? -1.0f : 1.0f);
                    CameraUserImpulseData->RotateYawImpulse += DeltaYawImpulse;
                    InConfig.bForceRotationalPhysics |= (DeltaYawImpulse != 0.0f);
                }
                else if (Key == EKeys::Gamepad_RightY)
                {
                    float DeltaPitchImpulse = GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.RotationMultiplier * (InConfig.bInvertY ? -1.0f : 1.0f);
                    CameraUserImpulseData->RotatePitchImpulse -= DeltaPitchImpulse;
                    InConfig.bForceRotationalPhysics |= (DeltaPitchImpulse != 0.0f);
                }
                else if (Key == EKeys::Gamepad_LeftTriggerAxis)
                {
                    CameraUserImpulseData->MoveUpDownImpulse -= GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.TranslationMultiplier;
                }
                else if (Key == EKeys::Gamepad_RightTriggerAxis)
                {
                    CameraUserImpulseData->MoveUpDownImpulse += GetFilteredDelta(UnfilteredDelta, ViewportDeadZoneConstants::STANDARD_DEAD_ZONE, StandardDeadZone) * InConfig.TranslationMultiplier;
                }
            }
        }

        if (bRelativeMovement)
        {
            for (TMap<FKey, EInputEvent>::TConstIterator KeyIt(JoystickState->KeyEventValues); KeyIt; ++KeyIt)
            {
                FKey Key             = KeyIt.Key();
                EInputEvent KeyState = KeyIt.Value();

                const bool bPressed  = (KeyState == IE_Pressed);
                const bool bRepeat   = (KeyState == IE_Repeat);

                if ((Key == EKeys::Gamepad_LeftShoulder) && (bPressed || bRepeat))
                {
                    CameraUserImpulseData->ZoomOutInImpulse += InConfig.ZoomMultiplier;
                }
                else if ((Key == EKeys::Gamepad_RightShoulder) && (bPressed || bRepeat))
                {
                    CameraUserImpulseData->ZoomOutInImpulse -= InConfig.ZoomMultiplier;
                }
                else if (RecordingInterpEd)
                {
                    bool bRepeatAllowed = RecordingInterpEd->IsRecordMenuChangeAllowedRepeat();
                    if ((Key == EKeys::Gamepad_DPad_Up) && bPressed)
                    {
                        const bool bNextMenuItem = false;
                        RecordingInterpEd->ChangeRecordingMenu(bNextMenuItem);
                        bRepeatAllowed = false;
                    }
                    else if ((Key == EKeys::Gamepad_DPad_Down) && bPressed)
                    {
                        const bool bNextMenuItem = true;
                        RecordingInterpEd->ChangeRecordingMenu(bNextMenuItem);
                        bRepeatAllowed = false;
                    }
                    else if ((Key == EKeys::Gamepad_DPad_Right) && (bPressed || (bRepeat && bRepeatAllowed)))
                    {
                        const bool bIncrease = true;
                        RecordingInterpEd->ChangeRecordingMenuValue(this, bIncrease);
                    }
                    else if ((Key == EKeys::Gamepad_DPad_Left) && (bPressed || (bRepeat && bRepeatAllowed)))
                    {
                        const bool bIncrease = false;
                        RecordingInterpEd->ChangeRecordingMenuValue(this, bIncrease);
                    }
                    else if ((Key == EKeys::Gamepad_RightThumbstick) && (bPressed))
                    {
                        const bool bIncrease = true;
                        RecordingInterpEd->ResetRecordingMenuValue(this);
                    }
                    else if ((Key == EKeys::Gamepad_LeftThumbstick) && (bPressed))
                    {
                        RecordingInterpEd->ToggleRecordMenuDisplay();
                    }
                    else if ((Key == EKeys::Gamepad_FaceButton_Bottom) && (bPressed))
                    {
                        RecordingInterpEd->ToggleRecordInterpValues();
                    }
                    else if ((Key == EKeys::Gamepad_FaceButton_Right) && (bPressed))
                    {
                        if (!RecordingInterpEd->GetMatineeActor()->bIsPlaying)
                        {
                            bool bLoop    = true;
                            bool bForward = true;
                            RecordingInterpEd->StartPlaying(bLoop, bForward);
                        }
                        else
                        {
                            RecordingInterpEd->StopPlaying();
                        }
                    }

                    if (!bRepeatAllowed)
                    {
                        // only respond to this event ONCE
                        JoystickState->KeyEventValues.Remove(Key);
                    }
                }
                if (bPressed)
                {
                    // instantly set to repeat to stock rapid flickering until the time out
                    JoystickState->KeyEventValues.Add(Key, IE_Repeat);
                }
            }
        }
    }
}

EMouseCursor::Type FEditorViewportClient::GetCursor(FViewport* InViewport, int32 X, int32 Y)
{
    EMouseCursor::Type MouseCursor = EMouseCursor::Default;

    // StaticFindObject is used lower down in this code, and that's not allowed while saving packages.
    if (GIsSavingPackage)
    {
        return MouseCursor;
    }

    bool bMoveCanvasMovement = ShouldUseMoveCanvasMovement();

    if (RequiredCursorVisibiltyAndAppearance.bOverrideAppearance &&
        RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible)
    {
        MouseCursor = RequiredCursorVisibiltyAndAppearance.RequiredCursor;
    }
    else if (MouseDeltaTracker->UsingDragTool())
    {
        MouseCursor = EMouseCursor::Default;
    }
    else if (!RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible)
    {
        MouseCursor = EMouseCursor::None;
    }
    // only camera movement gets the hand icon
    else if (bMoveCanvasMovement && (Widget->GetCurrentAxis() == EAxisList::None) && bHasMouseMovedSinceClick)
    {
        // We're grabbing the canvas so the icon should look "grippy"
        MouseCursor = EMouseCursor::GrabHandClosed;
    }
    else if (bMoveCanvasMovement &&
             bHasMouseMovedSinceClick &&
             (GetWidgetMode() == FWidget::WM_Translate || GetWidgetMode() == FWidget::WM_TranslateRotateZ || GetWidgetMode() == FWidget::WM_2D))
    {
        MouseCursor = EMouseCursor::CardinalCross;
    }
    // wyisyg mode
    else if (IsUsingAbsoluteTranslation(true) && bHasMouseMovedSinceClick)
    {
        MouseCursor = EMouseCursor::CardinalCross;
    }
    // Don't select widget axes by mouse over while they're being controlled by a mouse drag.
    else if (InViewport->IsCursorVisible() && !bWidgetAxisControlledByDrag)
    {
        // allow editor modes to override cursor
        EMouseCursor::Type EditorModeCursor = EMouseCursor::Default;
        if (ModeTools->GetCursor(EditorModeCursor))
        {
            MouseCursor = EditorModeCursor;
        }
        else
        {
            HHitProxy* HitProxy = InViewport->GetHitProxy(X, Y);

            // Change the mouse cursor if the user is hovering over something they can interact with.
            if (HitProxy && !bUsingOrbitCamera)
            {
                MouseCursor          = HitProxy->GetMouseCursor();
                bShouldCheckHitProxy = true;
            }
            else
            {
                // Turn off widget highlight if there currently is one
                if (Widget->GetCurrentAxis() != EAxisList::None)
                {
                    SetCurrentWidgetAxis(EAxisList::None);
                    Invalidate(false, false);
                }
            }
        }
    }

    // Allow the viewport interaction to override any previously set mouse cursor
    UWorld* World                               = GetWorld();
    UViewportWorldInteraction* WorldInteraction = (World ? Cast<UViewportWorldInteraction>(GEditor->GetEditorWorldExtensionsManager()->GetEditorWorldExtensions(World)->FindExtension(UViewportWorldInteraction::StaticClass())) : nullptr);
    if (WorldInteraction != nullptr)
    {
        if (WorldInteraction->ShouldForceCursor())
        {
            MouseCursor = EMouseCursor::Crosshairs;
            SetRequiredCursor(false, true);
            UpdateRequiredCursorVisibility();
        }
        else if (WorldInteraction->ShouldSuppressExistingCursor())
        {
            MouseCursor = EMouseCursor::None;
            SetRequiredCursor(false, false);
            UpdateRequiredCursorVisibility();
        }
    }

    CachedMouseX = X;
    CachedMouseY = Y;

    return MouseCursor;
}

bool FEditorViewportClient::IsOrtho() const
{
    return !IsPerspective();
}

bool FEditorViewportClient::IsPerspective() const
{
    return (GetViewportType() == LVT_Perspective);
}

bool FEditorViewportClient::IsAspectRatioConstrained() const
{
    return bUseControllingActorViewInfo && ControllingActorViewInfo.bConstrainAspectRatio;
}

ELevelViewportType FEditorViewportClient::GetViewportType() const
{
    ELevelViewportType EffectiveViewportType = ViewportType;
    if (bUseControllingActorViewInfo)
    {
        EffectiveViewportType = (ControllingActorViewInfo.ProjectionMode == ECameraProjectionMode::Perspective) ? LVT_Perspective : LVT_OrthoFreelook;
    }
    return EffectiveViewportType;
}

void FEditorViewportClient::SetViewportType(ELevelViewportType InViewportType)
{
    ViewportType = InViewportType;

    // Changing the type may also change the active view mode; re-apply that now
    ApplyViewMode(GetViewMode(), IsPerspective(), EngineShowFlags);

    // We might have changed to an orthographic viewport; if so, update any viewport links
    UpdateLinkedOrthoViewports(true);

    Invalidate();
}

void FEditorViewportClient::RotateViewportType()
{
    ViewportType = ViewOptions[ViewOptionIndex];

    // Changing the type may also change the active view mode; re-apply that now
    ApplyViewMode(GetViewMode(), IsPerspective(), EngineShowFlags);

    // We might have changed to an orthographic viewport; if so, update any viewport links
    UpdateLinkedOrthoViewports(true);

    Invalidate();

    if (ViewOptionIndex == 5)
    {
        ViewOptionIndex = 0;
    }
    else
    {
        ViewOptionIndex++;
    }
}

bool FEditorViewportClient::IsActiveViewportTypeInRotation() const
{
    return GetViewportType() == ViewOptions[ViewOptionIndex];
}

bool FEditorViewportClient::IsActiveViewportType(ELevelViewportType InViewportType) const
{
    return GetViewportType() == InViewportType;
}

// Updates real-time camera movement.  Should be called every viewport tick!
void FEditorViewportClient::UpdateCameraMovement(float DeltaTime)
{
    // We only want to move perspective cameras around like this
    if (Viewport != NULL && IsPerspective() && !ShouldOrbitCamera())
    {
        const bool bEnable = false;
        ToggleOrbitCamera(bEnable);

        const bool bIsUsingTrackpad = FSlateApplication::Get().IsUsingTrackpad();

        // Certain keys are only available while the flight camera input mode is active
        const bool bUsingFlightInput = IsFlightCameraInputModeActive() || bIsUsingTrackpad;

        // Is the current press unmodified?
        const bool bUnmodifiedPress = !IsAltPressed() && !IsShiftPressed() && !IsCtrlPressed() && !IsCmdPressed();

        // Do we want to use the regular arrow keys for flight input?
        // Because the arrow keys are used for things like nudging actors, we'll only do this while the press is unmodified
        const bool bRemapArrowKeys = bUnmodifiedPress;

        // Do we want to remap the various WASD keys for flight input?
        const bool bRemapWASDKeys =
            (bUnmodifiedPress || (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlExperimentalNavigation && IsShiftPressed())) &&
            (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlType == WASD_Always ||
             (bUsingFlightInput &&
              (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlType == WASD_RMBOnly && (Viewport->KeyState(EKeys::RightMouseButton) || Viewport->KeyState(EKeys::MiddleMouseButton) || Viewport->KeyState(EKeys::LeftMouseButton) || bIsUsingTrackpad)))) &&
            !MouseDeltaTracker->UsingDragTool();

        // Apply impulse from magnify gesture and reset impulses if we're using WASD keys
        CameraUserImpulseData->MoveForwardBackwardImpulse = GestureMoveForwardBackwardImpulse;
        CameraUserImpulseData->MoveRightLeftImpulse       = 0.0f;
        CameraUserImpulseData->MoveUpDownImpulse          = 0.0f;
        CameraUserImpulseData->ZoomOutInImpulse           = 0.0f;
        CameraUserImpulseData->RotateYawImpulse           = 0.0f;
        CameraUserImpulseData->RotatePitchImpulse         = 0.0f;
        CameraUserImpulseData->RotateRollImpulse          = 0.0f;

        GestureMoveForwardBackwardImpulse                 = 0.0f;

        bool bForwardKeyState                             = false;
        bool bBackwardKeyState                            = false;
        bool bRightKeyState                               = false;
        bool bLeftKeyState                                = false;

        bool bUpKeyState                                  = false;
        bool bDownKeyState                                = false;
        bool bZoomOutKeyState                             = false;
        bool bZoomInKeyState                              = false;
        // Iterate through all key mappings to generate key state flags
        for (uint32 i = 0; i < static_cast<uint8>(EMultipleKeyBindingIndex::NumChords); ++i)
        {
            EMultipleKeyBindingIndex ChordIndex = static_cast<EMultipleKeyBindingIndex>(i);
            bForwardKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Forward->GetActiveChord(ChordIndex)->Key);
            bBackwardKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Backward->GetActiveChord(ChordIndex)->Key);
            bRightKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Right->GetActiveChord(ChordIndex)->Key);
            bLeftKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Left->GetActiveChord(ChordIndex)->Key);

            bUpKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Up->GetActiveChord(ChordIndex)->Key);
            bDownKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().Down->GetActiveChord(ChordIndex)->Key);
            bZoomOutKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().FovZoomOut->GetActiveChord(ChordIndex)->Key);
            bZoomInKeyState |= Viewport->KeyState(FViewportNavigationCommands::Get().FovZoomIn->GetActiveChord(ChordIndex)->Key);
        }

        // Forward/back
        if ((bRemapWASDKeys && bForwardKeyState) ||
            (bRemapArrowKeys && Viewport->KeyState(EKeys::Up)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadEight)))
        {
            CameraUserImpulseData->MoveForwardBackwardImpulse += 1.0f;
        }
        if ((bRemapWASDKeys && bBackwardKeyState) ||
            (bRemapArrowKeys && Viewport->KeyState(EKeys::Down)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadTwo)))
        {
            CameraUserImpulseData->MoveForwardBackwardImpulse -= 1.0f;
        }

        // Right/left
        if ((bRemapWASDKeys && bRightKeyState) ||
            (bRemapArrowKeys && Viewport->KeyState(EKeys::Right)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadSix)))
        {
            CameraUserImpulseData->MoveRightLeftImpulse += 1.0f;
        }
        if ((bRemapWASDKeys && bLeftKeyState) ||
            (bRemapArrowKeys && Viewport->KeyState(EKeys::Left)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadFour)))
        {
            CameraUserImpulseData->MoveRightLeftImpulse -= 1.0f;
        }

        // Up/down
        if ((bRemapWASDKeys && bUpKeyState) ||
            (bUnmodifiedPress && Viewport->KeyState(EKeys::PageUp)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && (Viewport->KeyState(EKeys::NumPadNine) || Viewport->KeyState(EKeys::Add))))
        {
            CameraUserImpulseData->MoveUpDownImpulse += 1.0f;
        }
        if ((bRemapWASDKeys && bDownKeyState) ||
            (bUnmodifiedPress && Viewport->KeyState(EKeys::PageDown)) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && (Viewport->KeyState(EKeys::NumPadSeven) || Viewport->KeyState(EKeys::Subtract))))
        {
            CameraUserImpulseData->MoveUpDownImpulse -= 1.0f;
        }

        // Zoom FOV out/in
        if ((bRemapWASDKeys && bZoomOutKeyState) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadOne)))
        {
            CameraUserImpulseData->ZoomOutInImpulse += 1.0f;
        }
        if ((bRemapWASDKeys && bZoomInKeyState) ||
            (bUnmodifiedPress && bUseNumpadCameraControl && Viewport->KeyState(EKeys::NumPadThree)))
        {
            CameraUserImpulseData->ZoomOutInImpulse -= 1.0f;
        }

        // Record Stats
        if (CameraUserImpulseData->MoveForwardBackwardImpulse != 0 || CameraUserImpulseData->MoveRightLeftImpulse != 0)
        {
            FEditorViewportStats::Using(FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_WASD);
        }
        else if (CameraUserImpulseData->MoveUpDownImpulse != 0)
        {
            FEditorViewportStats::Using(FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_UP_DOWN);
        }
        else if (CameraUserImpulseData->ZoomOutInImpulse != 0)
        {
            FEditorViewportStats::Using(FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_FOV_ZOOM);
        }

        if (!CameraController->IsRotating())
        {
            CameraController->GetConfig().bForceRotationalPhysics = false;
        }

        bool bIgnoreJoystickControls = false;
        // if we're playing back (without recording), stop input from being processed
        if (RecordingInterpEd && RecordingInterpEd->GetMatineeActor())
        {
            if (RecordingInterpEd->GetMatineeActor()->bIsPlaying && !RecordingInterpEd->IsRecordingInterpValues())
            {
                bIgnoreJoystickControls = true;
            }

            CameraController->GetConfig().bPlanarCamera = (RecordingInterpEd->GetCameraMovementScheme() == MatineeConstants::ECameraScheme::CAMERA_SCHEME_PLANAR_CAM);
        }

        if (GetDefault<ULevelEditorViewportSettings>()->bLevelEditorJoystickControls)
        {
            // Now update for cached joystick info (relative movement first)
            UpdateCameraMovementFromJoystick(true, CameraController->GetConfig());

            // if we're not playing any cinematics right now
            if (!bIgnoreJoystickControls)
            {
                // Now update for cached joystick info (absolute movement second)
                UpdateCameraMovementFromJoystick(false, CameraController->GetConfig());
            }
        }

        FVector NewViewLocation  = GetViewLocation();
        FRotator NewViewRotation = GetViewRotation();
        FVector NewViewEuler     = GetViewRotation().Euler();
        float NewViewFOV         = ViewFOV;

        // We'll combine the regular camera speed scale (controlled by viewport toolbar setting) with
        // the flight camera speed scale (controlled by mouse wheel) and the CameraSpeedScalar (set in the transform viewport toolbar).
        const float CameraSpeed           = GetCameraSpeed();
        const float CameraBoost           = IsShiftPressed() ? 2.0f : 1.0f;
        const float FinalCameraSpeedScale = FlightCameraSpeedScale * CameraSpeed * GetCameraSpeedScalar() * CameraBoost;

        // Only allow FOV recoil if flight camera mode is currently inactive.
        const bool bAllowRecoilIfNoImpulse = (!bUsingFlightInput) && (!IsMatineeRecordingWindow());

        // Update the camera's position, rotation and FOV
        float EditorMovementDeltaUpperBound = 1.0f;  // Never "teleport" the camera further than a reasonable amount after a large quantum

#if UE_BUILD_DEBUG
        // Editor movement is very difficult in debug without this, due to hitching
        // It is better to freeze movement during a hitch than to fly off past where you wanted to go
        // (considering there will be further hitching trying to get back to where you were)
        EditorMovementDeltaUpperBound = .15f;
#endif
        // Check whether the camera is being moved by the mouse or keyboard
        bool bHasMovement = bIsTracking;

        if ((*CameraUserImpulseData).RotateYawVelocityModifier != 0.0f ||
            (*CameraUserImpulseData).RotatePitchVelocityModifier != 0.0f ||
            (*CameraUserImpulseData).RotateRollVelocityModifier != 0.0f ||
            (*CameraUserImpulseData).MoveForwardBackwardImpulse != 0.0f ||
            (*CameraUserImpulseData).MoveRightLeftImpulse != 0.0f ||
            (*CameraUserImpulseData).MoveUpDownImpulse != 0.0f ||
            (*CameraUserImpulseData).ZoomOutInImpulse != 0.0f ||
            (*CameraUserImpulseData).RotateYawImpulse != 0.0f ||
            (*CameraUserImpulseData).RotatePitchImpulse != 0.0f ||
            (*CameraUserImpulseData).RotateRollImpulse != 0.0f)
        {
            bHasMovement = true;
        }

        BeginCameraMovement(bHasMovement);

        CameraController->UpdateSimulation(
            *CameraUserImpulseData,
            FMath::Min(DeltaTime, EditorMovementDeltaUpperBound),
            bAllowRecoilIfNoImpulse,
            FinalCameraSpeedScale,
            NewViewLocation,
            NewViewEuler,
            NewViewFOV);

        // We'll zero out rotation velocity modifier after updating the simulation since these actions
        // are always momentary -- that is, when the user mouse looks some number of pixels,
        // we increment the impulse value right there
        {
            CameraUserImpulseData->RotateYawVelocityModifier   = 0.0f;
            CameraUserImpulseData->RotatePitchVelocityModifier = 0.0f;
            CameraUserImpulseData->RotateRollVelocityModifier  = 0.0f;
        }

        // Check for rotation difference within a small tolerance, ignoring winding
        if (!GetViewRotation().GetDenormalized().Equals(FRotator::MakeFromEuler(NewViewEuler).GetDenormalized(), SMALL_NUMBER))
        {
            NewViewRotation = FRotator::MakeFromEuler(NewViewEuler);
        }

        // See if translation/rotation have changed
        const bool bTransformDifferent = !NewViewLocation.Equals(GetViewLocation(), SMALL_NUMBER) || NewViewRotation != GetViewRotation();
        // See if FOV has changed
        const bool bFOVDifferent = !FMath::IsNearlyEqual(NewViewFOV, ViewFOV, float(SMALL_NUMBER));

        // If something has changed, tell the actor
        if (bTransformDifferent || bFOVDifferent)
        {
            // Something has changed!
            const bool bInvalidateChildViews = true;

            // When flying the camera around the hit proxies dont need to be invalidated since we are flying around and not clicking on anything
            const bool bInvalidateHitProxies = !IsFlightCameraActive();
            Invalidate(bInvalidateChildViews, bInvalidateHitProxies);

            // Update the FOV
            ViewFOV = NewViewFOV;

            // Actually move/rotate the camera
            if (bTransformDifferent)
            {
                MoveViewportPerspectiveCamera(
                    NewViewLocation - GetViewLocation(),
                    NewViewRotation - GetViewRotation());
            }

            // Invalidate the viewport widget
            if (EditorViewportWidget.IsValid())
            {
                EditorViewportWidget.Pin()->Invalidate();
            }
        }
    }
}

/**
 * Forcibly disables lighting show flags if there are no lights in the scene, or restores lighting show
 * flags if lights are added to the scene.
 */
void FEditorViewportClient::UpdateLightingShowFlags(FEngineShowFlags& InOutShowFlags)
{
    bool bViewportNeedsRefresh = false;

    if (bForcingUnlitForNewMap && !bInGameViewMode && IsPerspective())
    {
        // We'll only use default lighting for viewports that are viewing the main world
        if (GWorld != NULL && GetScene() != NULL && GetScene()->GetWorld() != NULL && GetScene()->GetWorld() == GWorld)
        {
            // Check to see if there are any lights in the scene
            bool bAnyLights = GetScene()->HasAnyLights();
            if (bAnyLights)
            {
                // Is unlit mode currently enabled?  We'll make sure that all of the regular unlit view
                // mode show flags are set (not just EngineShowFlags.Lighting), so we don't disrupt other view modes
                if (!InOutShowFlags.Lighting)
                {
                    // We have lights in the scene now so go ahead and turn lighting back on
                    // designer can see what they're interacting with!
                    InOutShowFlags.SetLighting(true);
                }

                // No longer forcing lighting to be off
                bForcingUnlitForNewMap = false;
            }
            else
            {
                // Is lighting currently enabled?
                if (InOutShowFlags.Lighting)
                {
                    // No lights in the scene, so make sure that lighting is turned off so the level
                    // designer can see what they're interacting with!
                    InOutShowFlags.SetLighting(false);
                }
            }
        }
    }
}

bool FEditorViewportClient::CalculateEditorConstrainedViewRect(FSlateRect& OutSafeFrameRect, FViewport* InViewport, float DPIScale)
{
    const int32 SizeX = InViewport->GetSizeXY().X / DPIScale;
    const int32 SizeY = InViewport->GetSizeXY().Y / DPIScale;

    OutSafeFrameRect  = FSlateRect(0, 0, SizeX, SizeY);
    float FixedAspectRatio;
    bool bSafeFrameActive = GetActiveSafeFrame(FixedAspectRatio);

    if (bSafeFrameActive)
    {
        // Get the size of the viewport
        float ActualAspectRatio = (float)SizeX / (float)SizeY;

        float SafeWidth         = SizeX;
        float SafeHeight        = SizeY;

        if (FixedAspectRatio < ActualAspectRatio)
        {
            // vertical bars required on left and right
            SafeWidth                = FixedAspectRatio * SizeY;
            float CorrectedHalfWidth = SafeWidth * 0.5f;
            float CentreX            = SizeX * 0.5f;
            float X1                 = CentreX - CorrectedHalfWidth;
            float X2                 = CentreX + CorrectedHalfWidth;
            OutSafeFrameRect         = FSlateRect(X1, 0, X2, SizeY);
        }
        else
        {
            // horizontal bars required on top and bottom
            SafeHeight                = SizeX / FixedAspectRatio;
            float CorrectedHalfHeight = SafeHeight * 0.5f;
            float CentreY             = SizeY * 0.5f;
            float Y1                  = CentreY - CorrectedHalfHeight;
            float Y2                  = CentreY + CorrectedHalfHeight;
            OutSafeFrameRect          = FSlateRect(0, Y1, SizeX, Y2);
        }
    }

    return bSafeFrameActive;
}

void FEditorViewportClient::DrawSafeFrames(FViewport& InViewport, FSceneView& View, FCanvas& Canvas)
{
    if (EngineShowFlags.CameraAspectRatioBars || EngineShowFlags.CameraSafeFrames)
    {
        FSlateRect SafeRect;
        if (CalculateEditorConstrainedViewRect(SafeRect, &InViewport, Canvas.GetDPIScale()))
        {
            if (EngineShowFlags.CameraSafeFrames)
            {
                FSlateRect InnerRect = SafeRect.InsetBy(FMargin(0.5f * SafePadding * SafeRect.GetSize().Size()));
                FCanvasBoxItem BoxItem(FVector2D(InnerRect.Left, InnerRect.Top), InnerRect.GetSize());
                BoxItem.SetColor(FLinearColor(0.0f, 0.0f, 0.0f, 0.5f));
                Canvas.DrawItem(BoxItem);
            }

            if (EngineShowFlags.CameraAspectRatioBars)
            {
                const int32 SizeX = InViewport.GetSizeXY().X;
                const int32 SizeY = InViewport.GetSizeXY().Y;
                FCanvasLineItem LineItem;
                LineItem.SetColor(FLinearColor(0.0f, 0.0f, 0.0f, 0.75f));

                if (SafeRect.GetSize().X < SizeX)
                {
                    DrawSafeFrameQuad(Canvas, FVector2D(0, SafeRect.Top), FVector2D(SafeRect.Left, SafeRect.Bottom));
                    DrawSafeFrameQuad(Canvas, FVector2D(SafeRect.Right, SafeRect.Top), FVector2D(SizeX, SafeRect.Bottom));
                    LineItem.Draw(&Canvas, FVector2D(SafeRect.Left, 0), FVector2D(SafeRect.Left, SizeY));
                    LineItem.Draw(&Canvas, FVector2D(SafeRect.Right, 0), FVector2D(SafeRect.Right, SizeY));
                }

                if (SafeRect.GetSize().Y < SizeY)
                {
                    DrawSafeFrameQuad(Canvas, FVector2D(SafeRect.Left, 0), FVector2D(SafeRect.Right, SafeRect.Top));
                    DrawSafeFrameQuad(Canvas, FVector2D(SafeRect.Left, SafeRect.Bottom), FVector2D(SafeRect.Right, SizeY));
                    LineItem.Draw(&Canvas, FVector2D(0, SafeRect.Top), FVector2D(SizeX, SafeRect.Top));
                    LineItem.Draw(&Canvas, FVector2D(0, SafeRect.Bottom), FVector2D(SizeX, SafeRect.Bottom));
                }
            }
        }
    }
}

void FEditorViewportClient::DrawSafeFrameQuad(FCanvas& Canvas, FVector2D V1, FVector2D V2)
{
    static const FLinearColor SafeFrameColor(0.0f, 0.0f, 0.0f, 1.0f);
    FCanvasUVTri UVTriItem;
    UVTriItem.V0_Pos = FVector2D(V1.X, V1.Y);
    UVTriItem.V1_Pos = FVector2D(V2.X, V1.Y);
    UVTriItem.V2_Pos = FVector2D(V1.X, V2.Y);
    FCanvasTriangleItem TriItem(UVTriItem, GWhiteTexture);
    UVTriItem.V0_Pos = FVector2D(V2.X, V1.Y);
    UVTriItem.V1_Pos = FVector2D(V2.X, V2.Y);
    UVTriItem.V2_Pos = FVector2D(V1.X, V2.Y);
    TriItem.TriangleList.Add(UVTriItem);
    TriItem.SetColor(SafeFrameColor);
    TriItem.Draw(&Canvas);
}

int32 FEditorViewportClient::SetStatEnabled(const TCHAR* InName, const bool bEnable, const bool bAll)
{
    if (bEnable)
    {
        check(!bAll);  // Not possible to enable all
        EnabledStats.AddUnique(InName);
    }
    else
    {
        if (bAll)
        {
            EnabledStats.Empty();
        }
        else
        {
            EnabledStats.Remove(InName);
        }
    }
    return EnabledStats.Num();
}

void FEditorViewportClient::HandleViewportStatCheckEnabled(const TCHAR* InName, bool& bOutCurrentEnabled, bool& bOutOthersEnabled)
{
    // Check to see which viewports have this enabled (current, non-current)
    const bool bEnabled = IsStatEnabled(InName);
    if (GStatProcessingViewportClient == this)
    {
        // Only if realtime and stats are also enabled should we show the stat as visible
        bOutCurrentEnabled = IsRealtime() && ShouldShowStats() && bEnabled;
    }
    else
    {
        bOutOthersEnabled |= bEnabled;
    }
}

void FEditorViewportClient::HandleViewportStatEnabled(const TCHAR* InName)
{
    // Just enable this on the active viewport
    if (GStatProcessingViewportClient == this)
    {
        SetShowStats(true);
        AddRealtimeOverride(true, LOCTEXT("RealtimeOverrideMessage_Stats", "Stats Display"));
        SetStatEnabled(InName, true);
    }
}

void FEditorViewportClient::HandleViewportStatDisabled(const TCHAR* InName)
{
    // Just disable this on the active viewport
    if (GStatProcessingViewportClient == this)
    {
        if (SetStatEnabled(InName, false) == 0)
        {
            SetShowStats(false);
            RemoveRealtimeOverride(LOCTEXT("RealtimeOverrideMessage_Stats", "Stats Display"));
        }
    }
}

void FEditorViewportClient::HandleViewportStatDisableAll(const bool bInAnyViewport)
{
    // Disable all on either all or the current viewport (depending on the flag)
    if (bInAnyViewport || GStatProcessingViewportClient == this)
    {
        SetShowStats(false);
        SetStatEnabled(NULL, false, true);
        RemoveRealtimeOverride(LOCTEXT("RealtimeOverrideMessage_Stats", "Stats Display"), /*bCheckMissingOverride*/ false);
    }
}

void FEditorViewportClient::HandleWindowDPIScaleChanged(TSharedRef<SWindow> InWindow)
{
    RequestUpdateDPIScale();
    Invalidate();
}

void FEditorViewportClient::UpdateMouseDelta()
{
    // Do nothing if a drag tool is being used.
    if (MouseDeltaTracker->UsingDragTool() || ModeTools->DisallowMouseDeltaTracking())
    {
        return;
    }

    // Stop tracking and do nothing else if we're tracking and the widget mode has changed mid-track.
    // It can confuse the widget code that handles the mouse movements.
    if (bIsTracking && MouseDeltaTracker->GetTrackingWidgetMode() != GetWidgetMode())
    {
        StopTracking();
        return;
    }

    FVector DragDelta = MouseDeltaTracker->GetDelta();

    GEditor->MouseMovement += DragDelta.GetAbs();

    if (Viewport)
    {
        if (!DragDelta.IsNearlyZero())
        {
            const bool LeftMouseButtonDown    = Viewport->KeyState(EKeys::LeftMouseButton);
            const bool MiddleMouseButtonDown  = Viewport->KeyState(EKeys::MiddleMouseButton);
            const bool RightMouseButtonDown   = Viewport->KeyState(EKeys::RightMouseButton);
            const bool bIsUsingTrackpad       = FSlateApplication::Get().IsUsingTrackpad();
            const bool bIsNonOrbitMiddleMouse = MiddleMouseButtonDown && !IsAltPressed();

            // If a tool is overriding current widget mode behavior, it may need to
            // temporarily set a different widget mode while converting mouse movement.
            ModeTools->PreConvertMouseMovement(this);

            // Convert the movement delta into drag/rotation deltas
            FVector Drag;
            FRotator Rot;
            FVector Scale;
            EAxisList::Type CurrentAxis = Widget->GetCurrentAxis();
            if (IsOrtho() && (LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown)
            {
                bWidgetAxisControlledByDrag = false;
                Widget->SetCurrentAxis(EAxisList::None);
                MouseDeltaTracker->ConvertMovementDeltaToDragRot(DragStartView, this, DragDelta, Drag, Rot, Scale);
                Widget->SetCurrentAxis(CurrentAxis);
                CurrentAxis = EAxisList::None;
            }
            else
            {
                if (DragStartView == nullptr)
                {
                    // Compute a view.
                    DragStartViewFamily = new FSceneViewFamily(FSceneViewFamily::ConstructionValues(
                                                                   Viewport,
                                                                   GetScene(),
                                                                   EngineShowFlags)
                                                                   .SetRealtimeUpdate(IsRealtime()));
                    DragStartView       = CalcSceneView(DragStartViewFamily);
                }
                // if Absolute Translation, and not just moving the camera around
                if (IsUsingAbsoluteTranslation(false))
                {
                    MouseDeltaTracker->AbsoluteTranslationConvertMouseToDragRot(DragStartView, this, Drag, Rot, Scale);
                }
                else
                {
                    MouseDeltaTracker->ConvertMovementDeltaToDragRot(DragStartView, this, DragDelta, Drag, Rot, Scale);
                }
            }

            ModeTools->PostConvertMouseMovement(this);

            const bool bInputHandledByGizmos = InputWidgetDelta(Viewport, CurrentAxis, Drag, Rot, Scale);

            if (!Rot.IsZero())
            {
                Widget->UpdateDeltaRotation();
            }

            if (!bInputHandledByGizmos)
            {
                if (ShouldOrbitCamera())
                {
                    bool bHasMovement = !DragDelta.IsNearlyZero();

                    BeginCameraMovement(bHasMovement);

                    FVector TempDrag;
                    FRotator TempRot;
                    InputAxisForOrbit(Viewport, DragDelta, TempDrag, TempRot);
                }
                else
                {
                    // Disable orbit camera
                    const bool bEnable = false;
                    ToggleOrbitCamera(bEnable);

                    if (ShouldPanOrDollyCamera())
                    {
                        bool bHasMovement = !Drag.IsNearlyZero() || !Rot.IsNearlyZero();

                        BeginCameraMovement(bHasMovement);

                        if (!IsOrtho())
                        {
                            const float CameraSpeed = GetCameraSpeed();
                            Drag *= CameraSpeed;
                        }
                        MoveViewportCamera(Drag, Rot);

                        if (IsPerspective() && LeftMouseButtonDown && !MiddleMouseButtonDown && !RightMouseButtonDown)
                        {
                            FEditorViewportStats::Using(FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_DOLLY);
                        }
                        else
                        {
                            if (!Drag.IsZero())
                            {
                                FEditorViewportStats::Using(IsPerspective() ? FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_PAN : FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_PAN);
                            }
                        }
                    }
                }
            }

            // Clean up
            MouseDeltaTracker->ReduceBy(DragDelta);

            Invalidate(false, false);
        }
    }
}

static bool IsOrbitRotationMode(FViewport* Viewport)
{
    bool LeftMouseButton   = Viewport->KeyState(EKeys::LeftMouseButton),
         MiddleMouseButton = Viewport->KeyState(EKeys::MiddleMouseButton),
         RightMouseButton  = Viewport->KeyState(EKeys::RightMouseButton);
    return LeftMouseButton && !MiddleMouseButton && !RightMouseButton;
}

static bool IsOrbitPanMode(FViewport* Viewport)
{
    bool LeftMouseButton   = Viewport->KeyState(EKeys::LeftMouseButton),
         MiddleMouseButton = Viewport->KeyState(EKeys::MiddleMouseButton),
         RightMouseButton  = Viewport->KeyState(EKeys::RightMouseButton);

    bool bAltPressed       = Viewport->KeyState(EKeys::LeftAlt) || Viewport->KeyState(EKeys::RightAlt);

    return (MiddleMouseButton && !LeftMouseButton && !RightMouseButton) || (!bAltPressed && MiddleMouseButton);
}

static bool IsOrbitZoomMode(FViewport* Viewport)
{
    bool LeftMouseButton   = Viewport->KeyState(EKeys::LeftMouseButton),
         MiddleMouseButton = Viewport->KeyState(EKeys::MiddleMouseButton),
         RightMouseButton  = Viewport->KeyState(EKeys::RightMouseButton);

    return RightMouseButton || (LeftMouseButton && MiddleMouseButton);
}

bool FEditorViewportClient::GetPivotForOrbit(FVector& Pivot) const
{
    return ModeTools->GetPivotForOrbit(Pivot);
}

void FEditorViewportClient::InputAxisForOrbit(FViewport* InViewport, const FVector& DragDelta, FVector& Drag, FRotator& Rot)
{
    FVector OrbitPoint;
    bool bHasCustomOrbitPivot = GetPivotForOrbit(OrbitPoint);
    if (GetDefault<ULevelEditorViewportSettings>()->bOrbitCameraAroundSelection && IsOrbitRotationMode(InViewport) && bHasCustomOrbitPivot)
    {
        // Override the default orbit behavior to allow orbiting around a given pivot
        // This uses different computations from the default orbit behavior so it must not ToggleOrbitCamera
        const bool bEnable = false;
        ToggleOrbitCamera(bEnable);

        ConvertMovementToOrbitDragRot(DragDelta, Drag, Rot);

        const FRotator ViewRotation = GetViewRotation();

        // Compute the look-at and view location centered on the orbit point
        const FVector LookAtOffset       = GetLookAtLocation() - OrbitPoint;
        const FVector ViewLocationOffset = GetViewLocation() - OrbitPoint;

        // When the roll is at 180 degrees, it means the view is upside down, so invert the yaw rotation
        if (ViewRotation.Roll == 180.f)
        {
            Rot.Yaw = -Rot.Yaw;
        }

        // Compute the delta rotation to apply as a transform
        FRotator DeltaRotation(Rot.Pitch, Rot.Yaw, Rot.Roll);
        FRotator ViewRotationNoPitch      = ViewRotation;
        ViewRotationNoPitch.Pitch         = 0;

        FTransform ViewRotationTransform  = FTransform(ViewRotationNoPitch);
        FTransform DeltaRotationTransform = ViewRotationTransform.Inverse() * FTransform(DeltaRotation) * ViewRotationTransform;

        // Apply the delta rotation to the view rotation
        FRotator RotatedView = (FTransform(ViewRotation) * DeltaRotationTransform).Rotator();

        // Correct the rotation to remove drift in the roll
        if (FMath::IsNearlyEqual(FMath::Abs(RotatedView.Roll), 180.f, 1.f))
        {
            RotatedView.Roll = 180.f;
        }
        else if (FMath::IsNearlyZero(RotatedView.Roll, 1.f))
        {
            RotatedView.Roll = 0.f;
        }
        else
        {
            // FTransform::Rotator() returns an invalid RotatedView with roll in it when the initial pitch is at +/-90 degrees due to a singularity
            // FVector::ToOrientatioRotator uses an alternate computation that doesn't suffer from the singularity. However, the roll it returns
            // is always 0 so it's not possible to tell if it's upside down and its yaw is flipped 180 degrees
            FVector ViewVector          = ViewRotation.Vector();
            FVector RotatedViewVector   = DeltaRotationTransform.TransformVector(ViewVector);
            FRotator RotatedViewRotator = RotatedViewVector.ToOrientationRotator();

            RotatedView                 = RotatedViewRotator + FRotator(0.f, -180.f, ViewRotation.Roll);
        }

        SetViewRotation(RotatedView);

        // Set the new rotated look-at
        FVector RotatedLookAtOffset = DeltaRotationTransform.TransformVector(LookAtOffset);
        FVector RotatedLookAt       = OrbitPoint + RotatedLookAtOffset;
        SetLookAtLocation(RotatedLookAt);

        // Set the new rotated view location
        FVector RotatedViewOffset   = DeltaRotationTransform.TransformVector(ViewLocationOffset);
        FVector RotatedViewLocation = OrbitPoint + RotatedViewOffset;
        SetViewLocation(RotatedViewLocation);

        FEditorViewportStats::Using(IsPerspective() ? FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_ROTATION : FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_ROTATION);

        if (IsPerspective())
        {
            PerspectiveCameraMoved();
        }
    }
    else
    {
        // Ensure orbit is enabled
        const bool bEnable = true;
        ToggleOrbitCamera(bEnable);

        FRotator TempRot = GetViewRotation();

        SetViewRotation(FRotator(0, 90, 0));
        ConvertMovementToOrbitDragRot(DragDelta, Drag, Rot);
        SetViewRotation(TempRot);

        Drag.X                                  = DragDelta.X;

        FViewportCameraTransform& ViewTransform = GetViewTransform();
        const float CameraSpeedDistanceScale    = ShouldScaleCameraSpeedByDistance() ? FMath::Min(FVector::Dist(GetViewLocation(), GetLookAtLocation()) / 1000.f, 1000.f) : 1.0f;

        if (IsOrbitRotationMode(InViewport))
        {
            SetViewRotation(GetViewRotation() + FRotator(Rot.Pitch, -Rot.Yaw, Rot.Roll));
            FEditorViewportStats::Using(IsPerspective() ? FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_ROTATION : FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_ROTATION);

            /*
             * Recalculates the view location according to the new SetViewRotation() did earlier.
             */
            SetViewLocation(ViewTransform.ComputeOrbitMatrix().Inverse().GetOrigin());
        }
        else if (IsOrbitPanMode(InViewport))
        {
            const bool bInvert      = GetDefault<ULevelEditorViewportSettings>()->bInvertMiddleMousePan;

            const float CameraSpeed = GetCameraSpeed();
            Drag *= CameraSpeed * CameraSpeedDistanceScale;

            FVector DeltaLocation = bInvert ? FVector(Drag.X, 0, -Drag.Z) : FVector(-Drag.X, 0, Drag.Z);

            FVector LookAt        = ViewTransform.GetLookAt();

            FMatrix RotMat =
                FTranslationMatrix(-LookAt) *
                FRotationMatrix(FRotator(0, GetViewRotation().Yaw, 0)) *
                FRotationMatrix(FRotator(0, 0, GetViewRotation().Pitch));

            FVector TransformedDelta = RotMat.InverseFast().TransformVector(DeltaLocation);

            SetLookAtLocation(GetLookAtLocation() + TransformedDelta);
            SetViewLocation(ViewTransform.ComputeOrbitMatrix().Inverse().GetOrigin());

            FEditorViewportStats::Using(IsPerspective() ? FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_PAN : FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_PAN);
        }
        else if (IsOrbitZoomMode(InViewport))
        {
            const bool bInvertY     = GetDefault<ULevelEditorViewportSettings>()->bInvertRightMouseDollyYAxis;

            FMatrix OrbitMatrix     = ViewTransform.ComputeOrbitMatrix().InverseFast();

            const float CameraSpeed = GetCameraSpeed();
            Drag *= CameraSpeed * CameraSpeedDistanceScale;

            FVector DeltaLocation = bInvertY ? FVector(0, Drag.X + Drag.Y, 0) : FVector(0, Drag.X + -Drag.Y, 0);

            FVector LookAt        = ViewTransform.GetLookAt();

            // Orient the delta down the view direction towards the look at
            FMatrix RotMat =
                FTranslationMatrix(-LookAt) *
                FRotationMatrix(FRotator(0, GetViewRotation().Yaw, 0)) *
                FRotationMatrix(FRotator(0, 0, GetViewRotation().Pitch));

            FVector TransformedDelta = RotMat.InverseFast().TransformVector(DeltaLocation);

            SetViewLocation(OrbitMatrix.GetOrigin() + TransformedDelta);

            FEditorViewportStats::Using(IsPerspective() ? FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_ZOOM : FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_ZOOM);
        }

        if (IsPerspective())
        {
            PerspectiveCameraMoved();
        }
    }
}

/**
 * forces a cursor update and marks the window as a move has occurred
 */
void FEditorViewportClient::MarkMouseMovedSinceClick()
{
    if (!bHasMouseMovedSinceClick)
    {
        bHasMouseMovedSinceClick = true;
        // if we care about the cursor
        if (Viewport->IsCursorVisible() && Viewport->HasMouseCapture())
        {
            // force a refresh
            Viewport->UpdateMouseCursor(true);
        }
    }
}

/** Determines whether this viewport is currently allowed to use Absolute Movement */
bool FEditorViewportClient::IsUsingAbsoluteTranslation(bool bAlsoCheckAbsoluteRotation) const
{
    bool bIsHotKeyAxisLocked   = Viewport->KeyState(EKeys::LeftControl) || Viewport->KeyState(EKeys::RightControl);
    bool bCameraLockedToWidget = !(Widget && Widget->GetCurrentAxis() & EAxisList::Screen) && (Viewport->KeyState(EKeys::LeftShift) || Viewport->KeyState(EKeys::RightShift));
    // Screen-space movement must always use absolute translation
    bool bScreenSpaceTransformation              = Widget && (Widget->GetCurrentAxis() == EAxisList::Screen) && GetWidgetMode() != FWidget::WM_Rotate;
    bool bAbsoluteMovementEnabled                = GetDefault<ULevelEditorViewportSettings>()->bUseAbsoluteTranslation || bScreenSpaceTransformation;
    bool bCurrentWidgetSupportsAbsoluteMovement  = FWidget::AllowsAbsoluteTranslationMovement(GetWidgetMode()) || bScreenSpaceTransformation;
    EAxisList::Type AxisType                     = Widget ? Widget->GetCurrentAxis() : EAxisList::None;

    bool bCurrentWidgetSupportsAbsoluteRotation  = bAlsoCheckAbsoluteRotation ? FWidget::AllowsAbsoluteRotationMovement(GetWidgetMode(), AxisType) : false;
    bool bWidgetActivelyTrackingAbsoluteMovement = Widget && (Widget->GetCurrentAxis() != EAxisList::None);

    const bool LeftMouseButtonDown               = Viewport->KeyState(EKeys::LeftMouseButton);
    const bool MiddleMouseButtonDown             = Viewport->KeyState(EKeys::MiddleMouseButton);
    const bool RightMouseButtonDown              = Viewport->KeyState(EKeys::RightMouseButton);

    const bool bAnyMouseButtonsDown              = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);

    return (!bCameraLockedToWidget && !bIsHotKeyAxisLocked && bAbsoluteMovementEnabled && (bCurrentWidgetSupportsAbsoluteMovement || bCurrentWidgetSupportsAbsoluteRotation) && bWidgetActivelyTrackingAbsoluteMovement && !IsOrtho() && bAnyMouseButtonsDown);
}

void FEditorViewportClient::SetMatineeRecordingWindow(IMatineeBase* InInterpEd)
{
    RecordingInterpEd = InInterpEd;
    if (CameraController)
    {
        FCameraControllerConfig Config = CameraController->GetConfig();
        RecordingInterpEd->LoadRecordingSettings(OUT Config);
        CameraController->SetConfig(Config);
    }
}

bool FEditorViewportClient::IsFlightCameraActive() const
{
    bool bIsFlightMovementKey = false;
    for (uint32 i = 0; i < static_cast<uint8>(EMultipleKeyBindingIndex::NumChords); ++i)
    {
        auto ChordIndex = static_cast<EMultipleKeyBindingIndex>(i);
        bIsFlightMovementKey |= (Viewport->KeyState(FViewportNavigationCommands::Get().Forward->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().Backward->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().Left->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().Right->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().Up->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().Down->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().FovZoomIn->GetActiveChord(ChordIndex)->Key) || Viewport->KeyState(FViewportNavigationCommands::Get().FovZoomOut->GetActiveChord(ChordIndex)->Key));
    }
    const bool bIsUsingTrackpad = FSlateApplication::Get().IsUsingTrackpad();

    // Movement key pressed and automatic movement enabled
    bIsFlightMovementKey &= (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlType == WASD_Always) | bIsUsingTrackpad;

    // Not using automatic movement but the flight camera is active
    bIsFlightMovementKey |= IsFlightCameraInputModeActive() && (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlType == WASD_RMBOnly);

    return !(Viewport->KeyState(EKeys::LeftControl) || Viewport->KeyState(EKeys::RightControl)) &&
           !(Viewport->KeyState(EKeys::LeftShift) || Viewport->KeyState(EKeys::RightShift)) &&
           !(Viewport->KeyState(EKeys::LeftAlt) || Viewport->KeyState(EKeys::RightAlt)) &&
           bIsFlightMovementKey;
}

void FEditorViewportClient::HandleToggleShowFlag(FEngineShowFlags::EShowFlag EngineShowFlagIndex)
{
    const bool bOldState = EngineShowFlags.GetSingleFlag(EngineShowFlagIndex);
    EngineShowFlags.SetSingleFlag(EngineShowFlagIndex, !bOldState);

    // If changing collision flag, need to do special handling for hidden objects.
    if (EngineShowFlagIndex == FEngineShowFlags::EShowFlag::SF_Collision)
    {
        UpdateHiddenCollisionDrawing();
    }

    // Invalidate clients which aren't real-time so we see the changes.
    Invalidate();
}

bool FEditorViewportClient::HandleIsShowFlagEnabled(FEngineShowFlags::EShowFlag EngineShowFlagIndex) const
{
    return EngineShowFlags.GetSingleFlag(EngineShowFlagIndex);
}

void FEditorViewportClient::ChangeBufferVisualizationMode(FName InName)
{
    SetViewMode(VMI_VisualizeBuffer);
    CurrentBufferVisualizationMode = InName;
}

bool FEditorViewportClient::IsBufferVisualizationModeSelected(FName InName) const
{
    return IsViewModeEnabled(VMI_VisualizeBuffer) && CurrentBufferVisualizationMode == InName;
}

FText FEditorViewportClient::GetCurrentBufferVisualizationModeDisplayName() const
{
    checkf(IsViewModeEnabled(VMI_VisualizeBuffer), TEXT("In order to call GetCurrentBufferVisualizationMode(), first you must set ViewMode to VMI_VisualizeBuffer."));
    return (CurrentBufferVisualizationMode.IsNone() ? FBufferVisualizationData::GetMaterialDefaultDisplayName() : GetBufferVisualizationData().GetMaterialDisplayName(CurrentBufferVisualizationMode));
}

bool FEditorViewportClient::IsVisualizeCalibrationMaterialEnabled() const
{
    // Get the list of requested buffers from the console
    const URendererSettings* Settings = GetDefault<URendererSettings>();
    check(Settings);

    return ((EngineShowFlags.VisualizeCalibrationCustom && Settings->VisualizeCalibrationCustomMaterialPath.IsValid()) ||
            (EngineShowFlags.VisualizeCalibrationColor && Settings->VisualizeCalibrationColorMaterialPath.IsValid()) ||
            (EngineShowFlags.VisualizeCalibrationGrayscale && Settings->VisualizeCalibrationGrayscaleMaterialPath.IsValid()));
}

void FEditorViewportClient::ChangeRayTracingDebugVisualizationMode(FName InName)
{
    SetViewMode(VMI_RayTracingDebug);
    CurrentRayTracingDebugVisualizationMode = InName;
}

bool FEditorViewportClient::IsRayTracingDebugVisualizationModeSelected(FName InName) const
{
    return IsViewModeEnabled(VMI_RayTracingDebug) && CurrentRayTracingDebugVisualizationMode == InName;
}

bool FEditorViewportClient::SupportsPreviewResolutionFraction() const
{
    // Don't do preview screen percentage for some view mode.
    switch (GetViewMode())
    {
        case VMI_BrushWireframe:
        case VMI_Wireframe:
        case VMI_LightComplexity:
        case VMI_LightmapDensity:
        case VMI_LitLightmapDensity:
        case VMI_ReflectionOverride:
        case VMI_StationaryLightOverlap:
        case VMI_CollisionPawn:
        case VMI_CollisionVisibility:
        case VMI_LODColoration:
        case VMI_PrimitiveDistanceAccuracy:
        case VMI_MeshUVDensityAccuracy:
        case VMI_HLODColoration:
        case VMI_GroupLODColoration:
            return false;
    }

    // Don't do preview screen percentage for buffer visualization.
    if (EngineShowFlags.VisualizeBuffer || IsVisualizeCalibrationMaterialEnabled())
    {
        return false;
    }

    return true;
}

int32 FEditorViewportClient::GetPreviewScreenPercentage() const
{
    // We expose the resolution fraction derived from DPI, to not lie to the artist when screen percentage = 100%.
    return FMath::RoundToInt(FMath::Clamp(
                                 PreviewResolutionFraction,
                                 FSceneViewScreenPercentageConfig::kMinTAAUpsampleResolutionFraction,
                                 FSceneViewScreenPercentageConfig::kMaxTAAUpsampleResolutionFraction) *
                             100.0f);
}

void FEditorViewportClient::SetPreviewScreenPercentage(int32 PreviewScreenPercentage)
{
    PreviewResolutionFraction = PreviewScreenPercentage / 100.0f;
}

bool FEditorViewportClient::SupportsLowDPIPreview() const
{
    return GetDPIDerivedResolutionFraction() < 1.0f;
}

bool FEditorViewportClient::IsLowDPIPreview()
{
    if (SceneDPIMode == ESceneDPIMode::EditorDefault)
    {
        return GetDefaultLowDPIPreviewValue();
    }
    return SceneDPIMode == ESceneDPIMode::EmulateLowDPI;
}

void FEditorViewportClient::SetLowDPIPreview(bool LowDPIPreview)
{
    if (LowDPIPreview == GetDefaultLowDPIPreviewValue())
    {
        SceneDPIMode = ESceneDPIMode::EditorDefault;
    }
    else
    {
        SceneDPIMode = LowDPIPreview ? ESceneDPIMode::EmulateLowDPI : ESceneDPIMode::HighDPI;
    }
}

bool FEditorViewportClient::ShouldScaleCameraSpeedByDistance() const
{
    return GetDefault<ULevelEditorViewportSettings>()->bUseDistanceScaledCameraSpeed;
}

bool FEditorViewportClient::InputKey(FViewport* InViewport, int32 ControllerId, FKey Key, EInputEvent Event, float /*AmountDepressed*/, bool /*Gamepad*/)
{
    if (bDisableInput)
    {
        return true;
    }

    // Let the current mode have a look at the input before reacting to it.
    if (ModeTools->InputKey(this, Viewport, Key, Event))
    {
        return true;
    }

    UEditorWorldExtensionCollection& EditorWorldExtensionCollection = *GEditor->GetEditorWorldExtensionsManager()->GetEditorWorldExtensions(GetWorld());
    if (EditorWorldExtensionCollection.InputKey(this, Viewport, Key, Event))
    {
        return true;
    }

    FInputEventState InputState(InViewport, Key, Event);

    bool bHandled = false;

    if ((IsOrtho() || InputState.IsAltButtonPressed()) && (Key == EKeys::Left || Key == EKeys::Right || Key == EKeys::Up || Key == EKeys::Down))
    {
        NudgeSelectedObjects(InputState);

        bHandled = true;
    }
    else if (Key == EKeys::Escape && Event == IE_Pressed && bIsTracking)
    {
        // Pressing Escape cancels the current operation
        AbortTracking();
        bHandled = true;
    }

    // If in ortho and right mouse button and ctrl is pressed
    if (!InputState.IsAltButtonPressed() && InputState.IsCtrlButtonPressed() && !InputState.IsButtonPressed(EKeys::LeftMouseButton) && !InputState.IsButtonPressed(EKeys::MiddleMouseButton) && InputState.IsButtonPressed(EKeys::RightMouseButton) && IsOrtho())
    {
        ModeTools->SetWidgetModeOverride(FWidget::WM_Rotate);
    }
    else
    {
        ModeTools->SetWidgetModeOverride(FWidget::WM_None);
    }

    const int32 HitX                    = InViewport->GetMouseX();
    const int32 HitY                    = InViewport->GetMouseY();

    FCachedJoystickState* JoystickState = GetJoystickState(ControllerId);
    if (JoystickState)
    {
        JoystickState->KeyEventValues.Add(Key, Event);
    }

    const bool bWasCursorVisible                          = InViewport->IsCursorVisible();
    const bool bWasSoftwareCursorVisible                  = InViewport->IsSoftwareCursorVisible();

    const bool AltDown                                    = InputState.IsAltButtonPressed();
    const bool ShiftDown                                  = InputState.IsShiftButtonPressed();
    const bool ControlDown                                = InputState.IsCtrlButtonPressed();

    RequiredCursorVisibiltyAndAppearance.bDontResetCursor = false;
    UpdateRequiredCursorVisibility();

    if (bWasCursorVisible != RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible || bWasSoftwareCursorVisible != RequiredCursorVisibiltyAndAppearance.bSoftwareCursorVisible)
    {
        bHandled = true;
    }

    // Compute a view.
    FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
                                           InViewport,
                                           GetScene(),
                                           EngineShowFlags)
                                           .SetRealtimeUpdate(IsRealtime()));
    FSceneView* View = CalcSceneView(&ViewFamily);

    if (!InputState.IsAnyMouseButtonDown())
    {
        bHasMouseMovedSinceClick = false;
    }

    // Start tracking if any mouse button is down and it was a tracking event (MouseButton/Ctrl/Shift/Alt):
    if (InputState.IsAnyMouseButtonDown() && (Event == IE_Pressed || Event == IE_Released) && (InputState.IsMouseButtonEvent() || InputState.IsCtrlButtonEvent() || InputState.IsAltButtonEvent() || InputState.IsShiftButtonEvent()))
    {
        StartTrackingDueToInput(InputState, *View);
        return true;
    }

    // If we are tracking and no mouse button is down and this input event released the mouse button stop tracking and process any clicks if necessary
    if (bIsTracking && !InputState.IsAnyMouseButtonDown() && InputState.IsMouseButtonEvent())
    {
        // Handle possible mouse click viewport
        ProcessClickInViewport(InputState, *View);

        // Stop tracking if no mouse button is down
        StopTracking();

        bHandled |= true;
    }

    if (Event == IE_DoubleClick)
    {
        ProcessDoubleClickInViewport(InputState, *View);
        return true;
    }

    if ((Key == EKeys::MouseScrollUp || Key == EKeys::MouseScrollDown || Key == EKeys::Add || Key == EKeys::Subtract) && (Event == IE_Pressed || Event == IE_Repeat) && IsOrtho())
    {
        OnOrthoZoom(InputState);
        bHandled |= true;

        if (Key == EKeys::MouseScrollUp || Key == EKeys::MouseScrollDown)
        {
            FEditorViewportStats::Using(FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_SCROLL);
        }
    }
    else if ((Key == EKeys::MouseScrollUp || Key == EKeys::MouseScrollDown) && Event == IE_Pressed && IsPerspective())
    {
        // If flight camera input is active, then the mouse wheel will control the speed of camera
        // movement
        if (IsFlightCameraInputModeActive())
        {
            OnChangeCameraSpeed(InputState);
        }
        else
        {
            OnDollyPerspectiveCamera(InputState);

            FEditorViewportStats::Using(FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_SCROLL);
        }

        bHandled |= true;
    }
    else if (IsFlightCameraActive() && Event != IE_Repeat)
    {
        // Flight camera control is active, so simply absorb the key.  The camera will update based
        // on currently pressed keys (Viewport->KeyState) in the Tick function.

        // mark "externally moved" so context menu doesn't come up
        MouseDeltaTracker->SetExternalMovement();
        bHandled |= true;
    }

    // apply the visibility and set the cursor positions
    ApplyRequiredCursorVisibility(true);
    return bHandled;
}

void FEditorViewportClient::StopTracking()
{
    if (bIsTracking)
    {
        DragStartView = nullptr;
        if (DragStartViewFamily != nullptr)
        {
            delete DragStartViewFamily;
            DragStartViewFamily = nullptr;
        }
        MouseDeltaTracker->EndTracking(this);

        Widget->SetCurrentAxis(EAxisList::None);

        // Force an immediate redraw of the viewport and hit proxy.
        // The results are required straight away, so it is not sufficient to defer the redraw until the next tick.
        constexpr bool bForceChildViewportRedraw = true;
        constexpr bool bInvalidateHitProxies     = true;
        Invalidate(bForceChildViewportRedraw, bInvalidateHitProxies);

        SetRequiredCursorOverride(false);

        bWidgetAxisControlledByDrag = false;

        // Update the hovered hit proxy here.  If the user didnt move the mouse
        // they still need to be able to pick up the gizmo without moving the mouse again
        HHitProxy* HitProxy = Viewport->GetHitProxy(CachedMouseX, CachedMouseY);
        CheckHoveredHitProxy(HitProxy);

        bIsTracking = false;
    }

    bHasMouseMovedSinceClick = false;
}

void FEditorViewportClient::AbortTracking()
{
    StopTracking();
}

bool FEditorViewportClient::IsInImmersiveViewport() const
{
    return ImmersiveDelegate.IsBound() ? ImmersiveDelegate.Execute() : false;
}

void FEditorViewportClient::StartTrackingDueToInput(const struct FInputEventState& InputState, FSceneView& View)
{
    // Check to see if the current event is a modifier key and that key was already in the
    // same state.
    EInputEvent Event             = InputState.GetInputEvent();
    FViewport* InputStateViewport = InputState.GetViewport();
    FKey Key                      = InputState.GetKey();

    bool bIsRedundantModifierEvent =
        (InputState.IsAltButtonEvent() && ((Event != IE_Released) == IsAltPressed())) ||
        (InputState.IsCtrlButtonEvent() && ((Event != IE_Released) == IsCtrlPressed())) ||
        (InputState.IsShiftButtonEvent() && ((Event != IE_Released) == IsShiftPressed()));

    if (MouseDeltaTracker->UsingDragTool() && InputState.IsLeftMouseButtonPressed() && Event != IE_Released)
    {
        bIsRedundantModifierEvent = true;
    }

    const int32 HitX = InputStateViewport->GetMouseX();
    const int32 HitY = InputStateViewport->GetMouseY();

    // First mouse down, note where they clicked
    LastMouseX = HitX;
    LastMouseY = HitY;

    // Only start (or restart) tracking mode if the current event wasn't a modifier key that
    // was already pressed or released.
    if (!bIsRedundantModifierEvent)
    {
        const bool bWasTracking = bIsTracking;

        // Stop current tracking
        if (bIsTracking)
        {
            MouseDeltaTracker->EndTracking(this);
            bIsTracking = false;
        }

        bDraggingByHandle = (Widget && Widget->GetCurrentAxis() != EAxisList::None);

        if (Event == IE_Pressed)
        {
            // Tracking initialization:
            GEditor->MouseMovement = FVector::ZeroVector;
        }

        // Start new tracking. Potentially reset the widget so that StartTracking can pick a new axis.
        if (Widget && (!bDraggingByHandle || InputState.IsCtrlButtonPressed()))
        {
            bWidgetAxisControlledByDrag = false;
            Widget->SetCurrentAxis(EAxisList::None);
        }
        const bool bNudge = false;
        MouseDeltaTracker->StartTracking(this, HitX, HitY, InputState, bNudge, !bWasTracking);
        bIsTracking = true;

        // if we are using a widget to drag by axis ensure the cursor is correct
        if (bDraggingByHandle == true)
        {
            // reset the flag to say we used a drag modifier	if we are using the widget handle
            if (bWidgetAxisControlledByDrag == false)
            {
                MouseDeltaTracker->ResetUsedDragModifier();
            }

            SetRequiredCursorOverride(true, EMouseCursor::CardinalCross);
        }

        // only reset the initial point when the mouse is actually clicked
        if (InputState.IsAnyMouseButtonDown() && Widget)
        {
            Widget->ResetInitialTranslationOffset();
        }

        // Don't update the cursor visibility if we don't have focus or mouse capture
        if (InputStateViewport->HasFocus() || InputStateViewport->HasMouseCapture())
        {
            // Need to call this one more time as the axis variable for the widget has just been updated
            UpdateRequiredCursorVisibility();
        }
    }
    ApplyRequiredCursorVisibility(true);
}

void FEditorViewportClient::ProcessClickInViewport(const FInputEventState& InputState, FSceneView& View)
{
    // Ignore actor manipulation if we're using a tool
    if (!MouseDeltaTracker->UsingDragTool())
    {
        EInputEvent Event             = InputState.GetInputEvent();
        FViewport* InputStateViewport = InputState.GetViewport();
        FKey Key                      = InputState.GetKey();

        const int32 HitX              = InputStateViewport->GetMouseX();
        const int32 HitY              = InputStateViewport->GetMouseY();

        // Calc the raw delta from the mouse to detect if there was any movement
        FVector RawMouseDelta = MouseDeltaTracker->GetRawDelta();

        // Note: We are using raw mouse movement to double check distance moved in low performance situations.  In low performance situations its possible
        // that we would get a mouse down and a mouse up before the next tick where GEditor->MouseMovment has not been updated.
        // In that situation, legitimate drags are incorrectly considered clicks
        bool bNoMouseMovment = RawMouseDelta.SizeSquared() < MOUSE_CLICK_DRAG_DELTA && GEditor->MouseMovement.SizeSquared() < MOUSE_CLICK_DRAG_DELTA;

        // If the mouse haven't moved too far, treat the button release as a click.
        if (bNoMouseMovment && !MouseDeltaTracker->WasExternalMovement())
        {
            TRefCountPtr<HHitProxy> HitProxy = InputStateViewport->GetHitProxy(HitX, HitY);

            // When clicking, the cursor should always appear at the location of the click and not move out from undere the user
            InputStateViewport->SetPreCaptureMousePosFromSlateCursor();
            ProcessClick(View, HitProxy, Key, Event, HitX, HitY);
        }
    }
}

bool FEditorViewportClient::IsAltPressed() const
{
    return Viewport->KeyState(EKeys::LeftAlt) || Viewport->KeyState(EKeys::RightAlt);
}

bool FEditorViewportClient::IsCtrlPressed() const
{
    return Viewport->KeyState(EKeys::LeftControl) || Viewport->KeyState(EKeys::RightControl);
}

bool FEditorViewportClient::IsShiftPressed() const
{
    return Viewport->KeyState(EKeys::LeftShift) || Viewport->KeyState(EKeys::RightShift);
}

bool FEditorViewportClient::IsCmdPressed() const
{
    return Viewport->KeyState(EKeys::LeftCommand) || Viewport->KeyState(EKeys::RightCommand);
}

void FEditorViewportClient::ProcessDoubleClickInViewport(const struct FInputEventState& InputState, FSceneView& View)
{
    // Stop current tracking
    if (bIsTracking)
    {
        MouseDeltaTracker->EndTracking(this);
        bIsTracking = false;
    }

    FViewport* InputStateViewport = InputState.GetViewport();
    EInputEvent Event             = InputState.GetInputEvent();
    FKey Key                      = InputState.GetKey();

    const int32 HitX              = InputStateViewport->GetMouseX();
    const int32 HitY              = InputStateViewport->GetMouseY();

    MouseDeltaTracker->StartTracking(this, HitX, HitY, InputState);
    bIsTracking            = true;
    GEditor->MouseMovement = FVector::ZeroVector;
    HHitProxy* HitProxy    = InputStateViewport->GetHitProxy(HitX, HitY);
    ProcessClick(View, HitProxy, Key, Event, HitX, HitY);
    MouseDeltaTracker->EndTracking(this);
    bIsTracking = false;

    // This needs to be set to false to allow the axes to update
    bWidgetAxisControlledByDrag = false;
    MouseDeltaTracker->ResetUsedDragModifier();
    SetRequiredCursor(true, false);
    ApplyRequiredCursorVisibility();
}

/** Determines if the new MoveCanvas movement should be used
 * @return - true if we should use the new drag canvas movement.  Returns false for combined object-camera movement and marquee selection
 */
bool FEditorViewportClient::ShouldUseMoveCanvasMovement() const
{
    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) ? true : false;
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton) ? true : false;
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton) ? true : false;
    const bool bMouseButtonDown      = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);

    const bool AltDown               = IsAltPressed();
    const bool ShiftDown             = IsShiftPressed();
    const bool ControlDown           = IsCtrlPressed();

    // if we're using the new move canvas mode, we're in an ortho viewport, and the mouse is down
    if (GetDefault<ULevelEditorViewportSettings>()->bPanMovesCanvas && IsOrtho() && bMouseButtonDown)
    {
        // MOVING CAMERA
        if (!MouseDeltaTracker->UsingDragTool() && AltDown == false && ShiftDown == false && ControlDown == false && (Widget->GetCurrentAxis() == EAxisList::None) && (LeftMouseButtonDown ^ RightMouseButtonDown))
        {
            return true;
        }

        // OBJECT MOVEMENT CODE
        if ((AltDown == false && ShiftDown == false && (LeftMouseButtonDown ^ RightMouseButtonDown)) &&
            ((GetWidgetMode() == FWidget::WM_Translate && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_TranslateRotateZ && Widget->GetCurrentAxis() != EAxisList::ZRotation && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_2D && Widget->GetCurrentAxis() != EAxisList::Rotate2D && Widget->GetCurrentAxis() != EAxisList::None)))
        {
            return true;
        }

        // ALL other cases hide the mouse
        return false;
    }
    else
    {
        // current system - do not show cursor when mouse is down
        return false;
    }
}

void FEditorViewportClient::DrawAxes(FViewport* InViewport, FCanvas* Canvas, const FRotator* InRotation, EAxisList::Type InAxis)
{
    FMatrix ViewTM = FMatrix::Identity;
    if (bUsingOrbitCamera)
    {
        FViewportCameraTransform& ViewTransform = GetViewTransform();
        ViewTM                                  = FRotationMatrix(ViewTransform.ComputeOrbitMatrix().InverseFast().Rotator());
    }
    else
    {
        ViewTM = FRotationMatrix(GetViewRotation());
    }

    if (InRotation)
    {
        ViewTM = FRotationMatrix(*InRotation);
    }

    const int32 SizeX = InViewport->GetSizeXY().X / Canvas->GetDPIScale();
    const int32 SizeY = InViewport->GetSizeXY().Y / Canvas->GetDPIScale();

    const FIntPoint AxisOrigin(30, SizeY - 30);
    const float AxisSize = 25.f;

    UFont* Font          = GEngine->GetSmallFont();
    int32 XL, YL;
    StringSize(Font, XL, YL, TEXT("Z"));

    FVector AxisVec;
    FIntPoint AxisEnd;
    FCanvasLineItem LineItem;
    FCanvasTextItem TextItem(FVector2D::ZeroVector, FText::GetEmpty(), Font, FLinearColor::White);
    if ((InAxis & EAxisList::X) == EAxisList::X)
    {
        AxisVec = AxisSize * ViewTM.InverseTransformVector(FVector(1, 0, 0));
        AxisEnd = AxisOrigin + FIntPoint(AxisVec.Y, -AxisVec.Z);
        LineItem.SetColor(FLinearColor::Red);
        TextItem.SetColor(FLinearColor::Red);
        LineItem.Draw(Canvas, AxisOrigin, AxisEnd);
        TextItem.Text = LOCTEXT("XAxis", "X");
        TextItem.Draw(Canvas, FVector2D(AxisEnd.X + 2, AxisEnd.Y - 0.5 * YL));
    }

    if ((InAxis & EAxisList::Y) == EAxisList::Y)
    {
        AxisVec = AxisSize * ViewTM.InverseTransformVector(FVector(0, 1, 0));
        AxisEnd = AxisOrigin + FIntPoint(AxisVec.Y, -AxisVec.Z);
        LineItem.SetColor(FLinearColor::Green);
        TextItem.SetColor(FLinearColor::Green);
        LineItem.Draw(Canvas, AxisOrigin, AxisEnd);
        TextItem.Text = LOCTEXT("YAxis", "Y");
        TextItem.Draw(Canvas, FVector2D(AxisEnd.X + 2, AxisEnd.Y - 0.5 * YL));
    }

    if ((InAxis & EAxisList::Z) == EAxisList::Z)
    {
        AxisVec = AxisSize * ViewTM.InverseTransformVector(FVector(0, 0, 1));
        AxisEnd = AxisOrigin + FIntPoint(AxisVec.Y, -AxisVec.Z);
        LineItem.SetColor(FLinearColor::Blue);
        TextItem.SetColor(FLinearColor::Blue);
        LineItem.Draw(Canvas, AxisOrigin, AxisEnd);
        TextItem.Text = LOCTEXT("ZAxis", "Z");
        TextItem.Draw(Canvas, FVector2D(AxisEnd.X + 2, AxisEnd.Y - 0.5 * YL));
    }
}

/** Convert the specified number (in cm or unreal units) into a readable string with relevant si units */
FString FEditorViewportClient::UnrealUnitsToSiUnits(float UnrealUnits)
{
    // Put it in mm to start off with
    UnrealUnits *= 10.f;

    const int32 OrderOfMagnitude = UnrealUnits > 0 ? FMath::TruncToInt(FMath::LogX(10.0f, UnrealUnits)) : 0;

    // Get an exponent applied to anything >= 1,000,000,000mm (1000km)
    const int32 Exponent         = (OrderOfMagnitude - 6) / 3;
    const FString ExponentString = Exponent > 0 ? FString::Printf(TEXT("e+%d"), Exponent * 3) : TEXT("");

    float ScaledNumber           = UnrealUnits;

    // Factor the order of magnitude into thousands and clamp it to km
    const int32 OrderOfThousands = OrderOfMagnitude / 3;
    if (OrderOfThousands != 0)
    {
        // Scale units to m or km (with the order of magnitude in 1000s)
        ScaledNumber /= FMath::Pow(1000.f, OrderOfThousands);
    }

    // Round to 2 S.F.
    const TCHAR* Approximation = TEXT("");
    {
        const int32 ScaledOrder     = OrderOfMagnitude % (FMath::Max(OrderOfThousands, 1) * 3);
        const float RoundingDivisor = FMath::Pow(10.f, ScaledOrder) / 10.f;
        const int32 Rounded         = FMath::TruncToInt(ScaledNumber / RoundingDivisor) * RoundingDivisor;
        if (ScaledNumber - Rounded > KINDA_SMALL_NUMBER)
        {
            ScaledNumber  = Rounded;
            Approximation = TEXT("~");
        }
    }

    if (OrderOfMagnitude <= 2)
    {
        // Always show cm not mm
        ScaledNumber /= 10;
    }

    static const TCHAR* UnitText[] = {TEXT("cm"), TEXT("m"), TEXT("km")};
    if (FMath::Fmod(ScaledNumber, 1.f) > KINDA_SMALL_NUMBER)
    {
        return FString::Printf(TEXT("%s%.1f%s%s"), Approximation, ScaledNumber, *ExponentString, UnitText[FMath::Min(OrderOfThousands, 2)]);
    }
    else
    {
        return FString::Printf(TEXT("%s%d%s%s"), Approximation, FMath::TruncToInt(ScaledNumber), *ExponentString, UnitText[FMath::Min(OrderOfThousands, 2)]);
    }
}

void FEditorViewportClient::DrawScaleUnits(FViewport* InViewport, FCanvas* Canvas, const FSceneView& InView)
{
    const float UnitsPerPixel = GetOrthoUnitsPerPixel(InViewport);

    // Find the closest power of ten to our target width
    static const int32 ApproxTargetMarkerWidthPx = 100;
    const float SegmentWidthUnits                = UnitsPerPixel > 0 ? FMath::Pow(10.f, FMath::RoundToFloat(FMath::LogX(10.f, UnitsPerPixel * ApproxTargetMarkerWidthPx))) : 0.f;

    const FString DisplayText                    = UnrealUnitsToSiUnits(SegmentWidthUnits);

    UFont* Font                                  = GEngine->GetTinyFont();
    int32 TextWidth, TextHeight;
    StringSize(Font, TextWidth, TextHeight, *DisplayText);

    // Origin is the bottom left of the scale
    const FIntPoint StartPoint(80, InViewport->GetSizeXY().Y / Canvas->GetDPIScale() - 30);
    const FIntPoint EndPoint = StartPoint + (UnitsPerPixel != 0 ? FIntPoint(SegmentWidthUnits / UnitsPerPixel, 0) : FIntPoint(0, 0));

    // Sort out the color for the text and widget
    FLinearColor HSVBackground      = InView.BackgroundColor.LinearRGBToHSV().CopyWithNewOpacity(1.f);
    const int32 Sign                = (0.5f - HSVBackground.B) / FMath::Abs(HSVBackground.B - 0.5f);
    HSVBackground.B                 = HSVBackground.B + Sign * 0.4f;
    const FLinearColor SegmentColor = HSVBackground.HSVToLinearRGB();

    const FIntPoint VerticalTickOffset(0, -3);

    // Draw the scale
    FCanvasLineItem LineItem;
    LineItem.SetColor(SegmentColor);
    LineItem.Draw(Canvas, StartPoint, StartPoint + VerticalTickOffset);
    LineItem.Draw(Canvas, StartPoint, EndPoint);
    LineItem.Draw(Canvas, EndPoint, EndPoint + VerticalTickOffset);

    // Draw the text
    FCanvasTextItem TextItem(EndPoint + FIntPoint(-(TextWidth + 3), -TextHeight), FText::FromString(DisplayText), Font, SegmentColor);
    TextItem.Draw(Canvas);
}

void FEditorViewportClient::OnOrthoZoom(const struct FInputEventState& InputState, float Scale)
{
    FViewport* InputStateViewport = InputState.GetViewport();
    FKey Key                      = InputState.GetKey();

    // Scrolling the mousewheel up/down zooms the orthogonal viewport in/out.
    int32 Delta = 25 * Scale;
    if (Key == EKeys::MouseScrollUp || Key == EKeys::Add)
    {
        Delta *= -1;
    }

    // Extract current state
    int32 ViewportWidth  = InputStateViewport->GetSizeXY().X;
    int32 ViewportHeight = InputStateViewport->GetSizeXY().Y;

    FVector OldOffsetFromCenter;

    const bool bCenterZoomAroundCursor = GetDefault<ULevelEditorViewportSettings>()->bCenterZoomAroundCursor && (Key == EKeys::MouseScrollDown || Key == EKeys::MouseScrollUp);

    if (bCenterZoomAroundCursor)
    {
        // Y is actually backwards, but since we're move the camera opposite the cursor to center, we negate both
        // therefore the x is negated
        // X Is backwards, negate it
        // default to viewport mouse position
        int32 CenterX = InputStateViewport->GetMouseX();
        int32 CenterY = InputStateViewport->GetMouseY();
        if (ShouldUseMoveCanvasMovement())
        {
            // use virtual mouse while dragging (normal mouse is clamped when invisible)
            CenterX = LastMouseX;
            CenterY = LastMouseY;
        }
        int32 DeltaFromCenterX = -(CenterX - (ViewportWidth >> 1));
        int32 DeltaFromCenterY = (CenterY - (ViewportHeight >> 1));
        switch (GetViewportType())
        {
            case LVT_OrthoXY:
                OldOffsetFromCenter.Set(DeltaFromCenterX, -DeltaFromCenterY, 0.0f);
                break;
            case LVT_OrthoXZ:
                OldOffsetFromCenter.Set(DeltaFromCenterX, 0.0f, DeltaFromCenterY);
                break;
            case LVT_OrthoYZ:
                OldOffsetFromCenter.Set(0.0f, DeltaFromCenterX, DeltaFromCenterY);
                break;
            case LVT_OrthoNegativeXY:
                OldOffsetFromCenter.Set(-DeltaFromCenterX, -DeltaFromCenterY, 0.0f);
                break;
            case LVT_OrthoNegativeXZ:
                OldOffsetFromCenter.Set(-DeltaFromCenterX, 0.0f, DeltaFromCenterY);
                break;
            case LVT_OrthoNegativeYZ:
                OldOffsetFromCenter.Set(0.0f, -DeltaFromCenterX, DeltaFromCenterY);
                break;
            case LVT_OrthoFreelook:
                //@TODO: CAMERA: How to handle this
                break;
            case LVT_Perspective:
                break;
        }
    }

    // save off old zoom
    const float OldUnitsPerPixel = GetOrthoUnitsPerPixel(Viewport);

    // update zoom based on input
    SetOrthoZoom(GetOrthoZoom() + (GetOrthoZoom() / CAMERA_ZOOM_DAMPEN) * Delta);
    SetOrthoZoom(FMath::Clamp<float>(GetOrthoZoom(), GetMinimumOrthoZoom(), MAX_ORTHOZOOM));

    if (bCenterZoomAroundCursor)
    {
        // This is the equivalent to moving the viewport to center about the cursor, zooming, and moving it back a proportional amount towards the cursor
        FVector FinalDelta = (GetOrthoUnitsPerPixel(Viewport) - OldUnitsPerPixel) * OldOffsetFromCenter;

        // now move the view location proportionally
        SetViewLocation(GetViewLocation() + FinalDelta);
    }

    const bool bInvalidateViews = true;

    // Update linked ortho viewport movement based on updated zoom and view location,
    UpdateLinkedOrthoViewports(bInvalidateViews);

    const bool bInvalidateHitProxies = true;

    Invalidate(bInvalidateViews, bInvalidateHitProxies);

    // mark "externally moved" so context menu doesn't come up
    MouseDeltaTracker->SetExternalMovement();
}

void FEditorViewportClient::OnDollyPerspectiveCamera(const FInputEventState& InputState)
{
    FKey Key = InputState.GetKey();

    // Scrolling the mousewheel up/down moves the perspective viewport forwards/backwards.
    FVector Drag(0, 0, 0);

    const FRotator& ViewRotation = GetViewRotation();
    Drag.X                       = FMath::Cos(ViewRotation.Yaw * PI / 180.f) * FMath::Cos(ViewRotation.Pitch * PI / 180.f);
    Drag.Y                       = FMath::Sin(ViewRotation.Yaw * PI / 180.f) * FMath::Cos(ViewRotation.Pitch * PI / 180.f);
    Drag.Z                       = FMath::Sin(ViewRotation.Pitch * PI / 180.f);

    if (Key == EKeys::MouseScrollDown)
    {
        Drag = -Drag;
    }

    const float CameraSpeed = GetCameraSpeed(GetDefault<ULevelEditorViewportSettings>()->MouseScrollCameraSpeed);
    Drag *= CameraSpeed * 32.f;

    const bool bDollyCamera = true;
    MoveViewportCamera(Drag, FRotator::ZeroRotator, bDollyCamera);
    Invalidate(true, true);

    FEditorDelegates::OnDollyPerspectiveCamera.Broadcast(Drag, ViewIndex);
}

void FEditorViewportClient::OnChangeCameraSpeed(const struct FInputEventState& InputState)
{
    const float MinCameraSpeedScale = 0.1f;
    const float MaxCameraSpeedScale = 10.0f;

    FKey Key                        = InputState.GetKey();

    if (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlExperimentalNavigation)
    {
        if (Key == EKeys::MouseScrollUp)
        {
            GetMutableDefault<ULevelEditorViewportSettings>()->CameraSpeed = FMath::Clamp<int32>(GetDefault<ULevelEditorViewportSettings>()->CameraSpeed + 1, 1, MaxCameraSpeeds);
        }
        else
        {
            GetMutableDefault<ULevelEditorViewportSettings>()->CameraSpeed = FMath::Clamp<int32>(GetDefault<ULevelEditorViewportSettings>()->CameraSpeed - 1, 1, MaxCameraSpeeds);
        }
    }
    else
    {
        // Adjust and clamp the camera speed scale
        if (Key == EKeys::MouseScrollUp)
        {
            if (FlightCameraSpeedScale >= 2.0f)
            {
                FlightCameraSpeedScale += 0.5f;
            }
            else if (FlightCameraSpeedScale >= 1.0f)
            {
                FlightCameraSpeedScale += 0.2f;
            }
            else
            {
                FlightCameraSpeedScale += 0.1f;
            }
        }
        else
        {
            if (FlightCameraSpeedScale > 2.49f)
            {
                FlightCameraSpeedScale -= 0.5f;
            }
            else if (FlightCameraSpeedScale >= 1.19f)
            {
                FlightCameraSpeedScale -= 0.2f;
            }
            else
            {
                FlightCameraSpeedScale -= 0.1f;
            }
        }

        FlightCameraSpeedScale = FMath::Clamp(FlightCameraSpeedScale, MinCameraSpeedScale, MaxCameraSpeedScale);

        if (FMath::IsNearlyEqual(FlightCameraSpeedScale, 1.0f, 0.01f))
        {
            // Snap to 1.0 if we're really close to that
            FlightCameraSpeedScale = 1.0f;
        }
    }
}

void FEditorViewportClient::AddReferencedObjects(FReferenceCollector& Collector)
{
    if (PreviewScene)
    {
        PreviewScene->AddReferencedObjects(Collector);
    }

    if (ViewState.GetReference())
    {
        ViewState.GetReference()->AddReferencedObjects(Collector);
    }

    for (FSceneViewStateReference& StereoViewState: StereoViewStates)
    {
        if (StereoViewState.GetReference())
        {
            StereoViewState.GetReference()->AddReferencedObjects(Collector);
        }
    }
}

FString FEditorViewportClient::GetReferencerName() const
{
    return TEXT("FEditorViewportClient");
}

void FEditorViewportClient::ProcessClick(class FSceneView& View, class HHitProxy* HitProxy, FKey Key, EInputEvent Event, uint32 HitX, uint32 HitY)
{
    const FViewportClick Click(&View, this, Key, Event, HitX, HitY);
    ModeTools->HandleClick(this, HitProxy, Click);
}

bool FEditorViewportClient::InputWidgetDelta(FViewport* InViewport, EAxisList::Type CurrentAxis, FVector& Drag, FRotator& Rot, FVector& Scale)
{
    if (ModeTools->InputDelta(this, Viewport, Drag, Rot, Scale))
    {
        if (ModeTools->AllowWidgetMove())
        {
            ModeTools->PivotLocation += Drag;
            ModeTools->SnappedLocation += Drag;
        }

        // Update visuals of the rotate widget
        ApplyDeltaToRotateWidget(Rot);
        return true;
    }
    else
    {
        return false;
    }
}

void FEditorViewportClient::SetWidgetMode(FWidget::EWidgetMode NewMode)
{
    if (!ModeTools->IsTracking() && !IsFlightCameraActive())
    {
        ModeTools->SetWidgetMode(NewMode);

        // force an invalidation (non-deferred) of the hit proxy here, otherwise we will
        // end up checking against an incorrect hit proxy if the cursor is not moved
        Viewport->InvalidateHitProxy();
        bShouldCheckHitProxy = true;

        // Fire event delegate
        ModeTools->BroadcastWidgetModeChanged(NewMode);
    }

    RedrawAllViewportsIntoThisScene();
}

bool FEditorViewportClient::CanSetWidgetMode(FWidget::EWidgetMode NewMode) const
{
    return ModeTools->UsesTransformWidget(NewMode) == true;
}

FWidget::EWidgetMode FEditorViewportClient::GetWidgetMode() const
{
    return ModeTools->GetWidgetMode();
}

FVector FEditorViewportClient::GetWidgetLocation() const
{
    return ModeTools->GetWidgetLocation();
}

FMatrix FEditorViewportClient::GetWidgetCoordSystem() const
{
    return ModeTools->GetCustomInputCoordinateSystem();
}

FMatrix FEditorViewportClient::GetLocalCoordinateSystem() const
{
    return ModeTools->GetLocalCoordinateSystem();
}

void FEditorViewportClient::SetWidgetCoordSystemSpace(ECoordSystem NewCoordSystem)
{
    ModeTools->SetCoordSystem(NewCoordSystem);
    RedrawAllViewportsIntoThisScene();
}

ECoordSystem FEditorViewportClient::GetWidgetCoordSystemSpace() const
{
    return ModeTools->GetCoordSystem();
}

void FEditorViewportClient::ApplyDeltaToRotateWidget(const FRotator& InRot)
{
    // apply rotation to translate rotate widget
    if (!InRot.IsZero())
    {
        FRotator TranslateRotateWidgetRotation(0, ModeTools->TranslateRotateXAxisAngle, 0);
        TranslateRotateWidgetRotation += InRot;
        ModeTools->TranslateRotateXAxisAngle = TranslateRotateWidgetRotation.Yaw;

        FRotator Widget2DRotation(ModeTools->TranslateRotate2DAngle, 0, 0);
        Widget2DRotation += InRot;
        ModeTools->TranslateRotate2DAngle = Widget2DRotation.Pitch;
    }
}

void FEditorViewportClient::RedrawAllViewportsIntoThisScene()
{
    Invalidate();
}

FSceneInterface* FEditorViewportClient::GetScene() const
{
    UWorld* World = GetWorld();
    if (World)
    {
        return World->Scene;
    }

    return NULL;
}

UWorld* FEditorViewportClient::GetWorld() const
{
    UWorld* OutWorldPtr = NULL;
    // If we have a valid scene get its world
    if (PreviewScene)
    {
        OutWorldPtr = PreviewScene->GetWorld();
    }
    if (OutWorldPtr == NULL)
    {
        OutWorldPtr = GWorld;
    }
    return OutWorldPtr;
}

void FEditorViewportClient::DrawCanvas(FViewport& InViewport, FSceneView& View, FCanvas& Canvas)
{
    // Information string
    Canvas.DrawShadowedString(4, 4, *ModeTools->InfoString, GEngine->GetSmallFont(), FColor::White);

    ModeTools->DrawHUD(this, &InViewport, &View, &Canvas);
}

void FEditorViewportClient::SetupViewForRendering(FSceneViewFamily& ViewFamily, FSceneView& View)
{
    if (ViewFamily.EngineShowFlags.Wireframe)
    {
        // Wireframe color is emissive-only, and mesh-modifying materials do not use material substitution, hence...
        View.DiffuseOverrideParameter  = FVector4(0.f, 0.f, 0.f, 0.f);
        View.SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
    }
    else if (ViewFamily.EngineShowFlags.OverrideDiffuseAndSpecular)
    {
        View.DiffuseOverrideParameter  = FVector4(GEngine->LightingOnlyBrightness.R, GEngine->LightingOnlyBrightness.G, GEngine->LightingOnlyBrightness.B, 0.0f);
        View.SpecularOverrideParameter = FVector4(.1f, .1f, .1f, 0.0f);
    }
    else if (ViewFamily.EngineShowFlags.LightingOnlyOverride)
    {
        View.DiffuseOverrideParameter  = FVector4(GEngine->LightingOnlyBrightness.R, GEngine->LightingOnlyBrightness.G, GEngine->LightingOnlyBrightness.B, 0.0f);
        View.SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
    }
    else if (ViewFamily.EngineShowFlags.ReflectionOverride)
    {
        View.DiffuseOverrideParameter   = FVector4(0.f, 0.f, 0.f, 0.f);
        View.SpecularOverrideParameter  = FVector4(1, 1, 1, 0.0f);
        View.NormalOverrideParameter    = FVector4(0, 0, 1, 0.0f);
        View.RoughnessOverrideParameter = FVector2D(0.0f, 0.0f);
    }

    if (!ViewFamily.EngineShowFlags.Diffuse)
    {
        View.DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
    }

    if (!ViewFamily.EngineShowFlags.Specular)
    {
        View.SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
    }

    View.CurrentBufferVisualizationMode = CurrentBufferVisualizationMode;
#if RHI_RAYTRACING
    View.CurrentRayTracingDebugVisualizationMode = CurrentRayTracingDebugVisualizationMode;
#endif

    // Look if the pixel inspector tool is on
    View.bUsePixelInspector                     = false;
    FPixelInspectorModule& PixelInspectorModule = FModuleManager::LoadModuleChecked<FPixelInspectorModule>(TEXT("PixelInspectorModule"));
    bool IsInspectorActive                      = PixelInspectorModule.IsPixelInspectorEnable();
    View.bUsePixelInspector                     = IsInspectorActive;
    FIntPoint InspectViewportPos                = FIntPoint(-1, -1);
    if (IsInspectorActive)
    {
        if (CurrentMousePos == FIntPoint(-1, -1))
        {
            uint32 CoordinateViewportId = 0;
            PixelInspectorModule.GetCoordinatePosition(InspectViewportPos, CoordinateViewportId);

            bool IsCoordinateInViewport = InspectViewportPos.X <= Viewport->GetSizeXY().X && InspectViewportPos.Y <= Viewport->GetSizeXY().Y;
            IsInspectorActive           = IsCoordinateInViewport && (CoordinateViewportId == View.State->GetViewKey());
            if (IsInspectorActive)
            {
                PixelInspectorModule.SetViewportInformation(View.State->GetViewKey(), Viewport->GetSizeXY());
            }
        }
        else
        {
            InspectViewportPos = CurrentMousePos;
            PixelInspectorModule.SetViewportInformation(View.State->GetViewKey(), Viewport->GetSizeXY());
            PixelInspectorModule.SetCoordinatePosition(InspectViewportPos, false);
        }
    }

    if (IsInspectorActive)
    {
        // Ready to send a request
        FSceneInterface* SceneInterface = GetScene();

        FVector2D InspectViewportUV(
            (InspectViewportPos.X + 0.5f) / float(View.UnscaledViewRect.Width()),
            (InspectViewportPos.Y + 0.5f) / float(View.UnscaledViewRect.Height()));

        PixelInspectorModule.CreatePixelInspectorRequest(InspectViewportUV, View.State->GetViewKey(), SceneInterface, bInGameViewMode, View.State->GetPreExposure());
    }
    else if (!View.bUsePixelInspector && CurrentMousePos != FIntPoint(-1, -1))
    {
        // Track in case the user hit esc key to stop inspecting pixel
        PixelInspectorRealtimeManagement(this, true);
    }
}

void FEditorViewportClient::Draw(FViewport* InViewport, FCanvas* Canvas)
{
    FViewport* ViewportBackup = Viewport;
    Viewport                  = InViewport ? InViewport : Viewport;

    // Determine whether we should use world time or real time based on the scene.
    float TimeSeconds;
    float RealTimeSeconds;
    float DeltaTimeSeconds;

    UWorld* World = GetWorld();
    if (!World || (GetScene() != World->Scene) || UseAppTime())
    {
        // Use time relative to start time to avoid issues with float vs double
        TimeSeconds      = FApp::GetCurrentTime() - GStartTime;
        RealTimeSeconds  = FApp::GetCurrentTime() - GStartTime;
        DeltaTimeSeconds = FApp::GetDeltaTime();
    }
    else
    {
        TimeSeconds      = World->GetTimeSeconds();
        RealTimeSeconds  = World->GetRealTimeSeconds();
        DeltaTimeSeconds = World->GetDeltaSeconds();
    }

    // Allow HMD to modify the view later, just before rendering
    const bool bStereoRendering = GEngine->IsStereoscopic3D(InViewport);
    FCanvas* DebugCanvas        = Viewport->GetDebugCanvas();
    if (DebugCanvas)
    {
        DebugCanvas->SetScaledToRenderTarget(bStereoRendering);
        DebugCanvas->SetStereoRendering(bStereoRendering);
    }
    Canvas->SetScaledToRenderTarget(bStereoRendering);
    Canvas->SetStereoRendering(bStereoRendering);

    FEngineShowFlags UseEngineShowFlags = EngineShowFlags;
    if (OverrideShowFlagsFunc)
    {
        OverrideShowFlagsFunc(UseEngineShowFlags);
    }

    // Setup a FSceneViewFamily/FSceneView for the viewport.
    FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
                                           Canvas->GetRenderTarget(),
                                           GetScene(),
                                           UseEngineShowFlags)
                                           .SetWorldTimes(TimeSeconds, DeltaTimeSeconds, RealTimeSeconds)
                                           .SetRealtimeUpdate(IsRealtime() && FSlateThrottleManager::Get().IsAllowingExpensiveTasks())
                                           .SetViewModeParam(ViewModeParam, ViewModeParamName));

    ViewFamily.EngineShowFlags = UseEngineShowFlags;

    ViewFamily.bIsHDR          = Viewport->IsHDRViewport();

    if (ModeTools->GetActiveMode(FBuiltinEditorModes::EM_InterpEdit) == 0 || !AllowsCinematicControl())
    {
        if (!UseEngineShowFlags.Game)
        {
            // in the editor, disable camera motion blur and other rendering features that rely on the former frame
            // unless the view port is Matinee controlled
            ViewFamily.EngineShowFlags.CameraInterpolation = 0;
        }

        if (!bStereoRendering)
        {
            // stereo is enabled, as many HMDs require this for proper visuals
            ViewFamily.EngineShowFlags.SetScreenPercentage(false);
        }
    }

    ViewFamily.ViewExtensions = GEngine->ViewExtensions->GatherActiveExtensions(FSceneViewExtensionContext(InViewport));

    for (auto ViewExt: ViewFamily.ViewExtensions)
    {
        ViewExt->SetupViewFamily(ViewFamily);
    }

    EViewModeIndex CurrentViewMode     = GetViewMode();
    ViewFamily.ViewMode                = CurrentViewMode;

    const bool bVisualizeBufferEnabled = CurrentViewMode == VMI_VisualizeBuffer && CurrentBufferVisualizationMode != NAME_None;
    const bool bRayTracingDebugEnabled = CurrentViewMode == VMI_RayTracingDebug && CurrentRayTracingDebugVisualizationMode != NAME_None;
    const bool bCanDisableTonemapper   = bVisualizeBufferEnabled || (bRayTracingDebugEnabled && !FRayTracingDebugVisualizationMenuCommands::DebugModeShouldBeTonemapped(CurrentRayTracingDebugVisualizationMode));

    EngineShowFlagOverride(ESFIM_Editor, ViewFamily.ViewMode, ViewFamily.EngineShowFlags, bCanDisableTonemapper);
    EngineShowFlagOrthographicOverride(IsPerspective(), ViewFamily.EngineShowFlags);

    UpdateLightingShowFlags(ViewFamily.EngineShowFlags);

    ViewFamily.ExposureSettings     = ExposureSettings;

    ViewFamily.LandscapeLODOverride = LandscapeLODOverride;

    // Setup the screen percentage and upscaling method for the view family.
    bool bFinalScreenPercentageShowFlag;
    {
        checkf(ViewFamily.GetScreenPercentageInterface() == nullptr,
               TEXT("Some code has tried to set up an alien screen percentage driver, that could be wrong if not supported very well by the RHI."));

        // If not doing VR rendering, apply DPI derived resolution fraction even if show flag is disabled
        if (!bStereoRendering && SupportsLowDPIPreview() && IsLowDPIPreview() && ViewFamily.SupportsScreenPercentage())
        {
            ViewFamily.SecondaryViewFraction = GetDPIDerivedResolutionFraction();
        }

        // Setup custom upscaler and screen percentage.
        if (GCustomEditorStaticScreenPercentage && ViewFamily.ViewMode == EViewModeIndex::VMI_Lit)
        {
            GCustomEditorStaticScreenPercentage->SetupEditorViewFamily(ViewFamily, this);
        }

        // If a screen percentage interface was not set by one of the view extension, then set the legacy one.
        if (ViewFamily.GetScreenPercentageInterface() == nullptr)
        {
            float GlobalResolutionFraction = 1.0f;

            // If not doing VR rendering, apply preview resolution fraction.
            if (!bStereoRendering && SupportsPreviewResolutionFraction() && ViewFamily.SupportsScreenPercentage())
            {
                GlobalResolutionFraction = PreviewResolutionFraction;

                // Force screen percentage's engine show flag to be turned on for preview screen percentage.
                ViewFamily.EngineShowFlags.ScreenPercentage = (GlobalResolutionFraction != 1.0);
            }

            // In editor viewport, we ignore r.ScreenPercentage and FPostProcessSettings::ScreenPercentage by design.
            ViewFamily.SetScreenPercentageInterface(new FLegacyScreenPercentageDriver(
                ViewFamily, GlobalResolutionFraction, /* AllowPostProcessSettingsScreenPercentage = */ false));
        }

        check(ViewFamily.GetScreenPercentageInterface() != nullptr);

        bFinalScreenPercentageShowFlag = ViewFamily.EngineShowFlags.ScreenPercentage;
    }

    FSceneView* View = nullptr;

    // Stereo rendering
    const bool bStereoDeviceActive = bStereoRendering && GEngine->StereoRenderingDevice.IsValid();
    int32 NumViews                 = bStereoRendering ? GEngine->StereoRenderingDevice->GetDesiredNumberOfViews(bStereoRendering) : 1;
    for (int StereoViewIndex = 0; StereoViewIndex < NumViews; ++StereoViewIndex)
    {
        const EStereoscopicPass StereoPass = bStereoRendering ? GEngine->StereoRenderingDevice->GetViewPassForIndex(bStereoRendering, StereoViewIndex) : eSSP_FULL;

        View                               = CalcSceneView(&ViewFamily, StereoPass);

        SetupViewForRendering(ViewFamily, *View);

        FSlateRect SafeFrame;
        View->CameraConstrainedViewRect = View->UnscaledViewRect;
        if (CalculateEditorConstrainedViewRect(SafeFrame, Viewport, Canvas->GetDPIScale()))
        {
            View->CameraConstrainedViewRect = FIntRect(SafeFrame.Left, SafeFrame.Top, SafeFrame.Right, SafeFrame.Bottom);
        }
    }

    if (IsAspectRatioConstrained())
    {
        // Clear the background to black if the aspect ratio is constrained, as the scene view won't write to all pixels.
        Canvas->Clear(FLinearColor::Black);
    }

    // Make sure the engine show flag for screen percentage is still what it was when setting up the screen percentage interface
    ViewFamily.EngineShowFlags.ScreenPercentage = bFinalScreenPercentageShowFlag;

    // Draw the 3D scene
    GetRendererModule().BeginRenderingViewFamily(Canvas, &ViewFamily);

    if (View)
    {
        DrawCanvas(*Viewport, *View, *Canvas);

        DrawSafeFrames(*Viewport, *View, *Canvas);
    }

    // Remove temporary debug lines.
    // Possibly a hack. Lines may get added without the scene being rendered etc.
    if (World->LineBatcher != NULL && (World->LineBatcher->BatchedLines.Num() || World->LineBatcher->BatchedPoints.Num() || World->LineBatcher->BatchedMeshes.Num()))
    {
        World->LineBatcher->Flush();
    }

    if (World->ForegroundLineBatcher != NULL && (World->ForegroundLineBatcher->BatchedLines.Num() || World->ForegroundLineBatcher->BatchedPoints.Num() || World->ForegroundLineBatcher->BatchedMeshes.Num()))
    {
        World->ForegroundLineBatcher->Flush();
    }

    // Draw the widget.
    if (Widget && bShowWidget)
    {
        Widget->DrawHUD(Canvas);
    }

    // Axes indicators
    if (bDrawAxes && !ViewFamily.EngineShowFlags.Game && !GLevelEditorModeTools().IsViewportUIHidden() && !IsVisualizeCalibrationMaterialEnabled())
    {
        switch (GetViewportType())
        {
            case LVT_OrthoXY: {
                const FRotator XYRot(-90.0f, -90.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &XYRot, EAxisList::XY);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            case LVT_OrthoXZ: {
                const FRotator XZRot(0.0f, -90.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &XZRot, EAxisList::XZ);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            case LVT_OrthoYZ: {
                const FRotator YZRot(0.0f, 0.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &YZRot, EAxisList::YZ);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            case LVT_OrthoNegativeXY: {
                const FRotator XYRot(90.0f, 90.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &XYRot, EAxisList::XY);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            case LVT_OrthoNegativeXZ: {
                const FRotator XZRot(0.0f, 90.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &XZRot, EAxisList::XZ);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            case LVT_OrthoNegativeYZ: {
                const FRotator YZRot(0.0f, 180.0f, 0.0f);
                DrawAxes(Viewport, Canvas, &YZRot, EAxisList::YZ);
                if (View)
                {
                    DrawScaleUnits(Viewport, Canvas, *View);
                }
                break;
            }
            default: {
                DrawAxes(Viewport, Canvas);
                break;
            }
        }
    }

    // NOTE: DebugCanvasObject will be created by UDebugDrawService::Draw() if it doesn't already exist.
    UDebugDrawService::Draw(ViewFamily.EngineShowFlags, Viewport, View, DebugCanvas);
    UCanvas* DebugCanvasObject = FindObjectChecked<UCanvas>(GetTransientPackage(), TEXT("DebugCanvasObject"));
    DebugCanvasObject->Canvas  = DebugCanvas;
    DebugCanvasObject->Init(Viewport->GetSizeXY().X, Viewport->GetSizeXY().Y, View, DebugCanvas);

    // Stats display
    if (IsRealtime() && ShouldShowStats() && DebugCanvas)
    {
        const int32 XPos = 4;
        TArray<FDebugDisplayProperty> EmptyPropertyArray;
        DrawStatsHUD(World, Viewport, DebugCanvas, NULL, EmptyPropertyArray, GetViewLocation(), GetViewRotation());
    }

    if (bStereoRendering && GEngine->XRSystem.IsValid())
    {
#if 0 && !UE_BUILD_SHIPPING  // TODO remove DrawDebug from the IHeadmountedDisplayInterface
		GEngine->XRSystem->DrawDebug(DebugCanvasObject);
#endif
    }

    if (!IsRealtime())
    {
        // Wait for the rendering thread to finish drawing the view before returning.
        // This reduces the apparent latency of dragging the viewport around.
        FlushRenderingCommands();
    }

    Viewport = ViewportBackup;
}

void FEditorViewportClient::Draw(const FSceneView* View, FPrimitiveDrawInterface* PDI)
{
    // Draw the drag tool.
    MouseDeltaTracker->Render3DDragTool(View, PDI);

    // Draw the widget.
    if (Widget && bShowWidget)
    {
        Widget->Render(View, PDI, this);
    }

    if (bUsesDrawHelper)
    {
        DrawHelper.Draw(View, PDI);
    }

    ModeTools->DrawActiveModes(View, PDI);

    // Draw the current editor mode.
    ModeTools->Render(View, Viewport, PDI);

    // Draw the preview scene light visualization
    DrawPreviewLightVisualization(View, PDI);

    // This viewport was just rendered, reset this value.
    FramesSinceLastDraw = 0;
}

void FEditorViewportClient::DrawPreviewLightVisualization(const FSceneView* View, FPrimitiveDrawInterface* PDI)
{
    // Draw the indicator of the current light direction if it was recently moved
    if ((PreviewScene != nullptr) && (PreviewScene->DirectionalLight != nullptr) && (MovingPreviewLightTimer > 0.0f))
    {
        const float A                 = MovingPreviewLightTimer / PreviewLightConstants::MovingPreviewLightTimerDuration;

        ULightComponent* Light        = PreviewScene->DirectionalLight;

        const FLinearColor ArrowColor = Light->LightColor;

        // Figure out where the light is (ignoring position for directional lights)
        const FTransform LightLocalToWorldRaw = Light->GetComponentToWorld();
        FTransform LightLocalToWorld          = LightLocalToWorldRaw;
        if (Light->IsA(UDirectionalLightComponent::StaticClass()))
        {
            LightLocalToWorld.SetTranslation(FVector::ZeroVector);
        }
        LightLocalToWorld.SetScale3D(FVector(1.0f));

        // Project the last mouse position during the click into world space
        FVector LastMouseWorldPos;
        FVector LastMouseWorldDir;
        View->DeprojectFVector2D(MovingPreviewLightSavedScreenPos, /*out*/ LastMouseWorldPos, /*out*/ LastMouseWorldDir);

        // The world pos may be nuts due to a super distant near plane for orthographic cameras, so find the closest
        // point to the origin along the ray
        LastMouseWorldPos = FMath::ClosestPointOnLine(LastMouseWorldPos, LastMouseWorldPos + LastMouseWorldDir * WORLD_MAX, FVector::ZeroVector);

        // Figure out the radius to draw the light preview ray at
        const FVector LightToMousePos  = LastMouseWorldPos - LightLocalToWorld.GetTranslation();
        const float LightToMouseRadius = FMath::Max(LightToMousePos.Size(), PreviewLightConstants::MinMouseRadius);

        const float ArrowLength        = FMath::Max(PreviewLightConstants::MinArrowLength, LightToMouseRadius * PreviewLightConstants::MouseLengthToArrowLenghtRatio);
        const float ArrowSize          = PreviewLightConstants::ArrowLengthToSizeRatio * ArrowLength;
        const float ArrowThickness     = FMath::Max(PreviewLightConstants::ArrowLengthToThicknessRatio * ArrowLength, PreviewLightConstants::MinArrowThickness);

        const FVector ArrowOrigin      = LightLocalToWorld.TransformPosition(FVector(-LightToMouseRadius - 0.5f * ArrowLength, 0.0f, 0.0f));
        const FVector ArrowDirection   = LightLocalToWorld.TransformVector(FVector(-1.0f, 0.0f, 0.0f));

        const FQuatRotationTranslationMatrix ArrowToWorld(LightLocalToWorld.GetRotation(), ArrowOrigin);

        DrawDirectionalArrow(PDI, ArrowToWorld, ArrowColor, ArrowLength, ArrowSize, SDPG_World, ArrowThickness);
    }
}

void FEditorViewportClient::RenderDragTool(const FSceneView* View, FCanvas* Canvas)
{
    MouseDeltaTracker->RenderDragTool(View, Canvas);
}

FLinearColor FEditorViewportClient::GetBackgroundColor() const
{
    return PreviewScene ? PreviewScene->GetBackgroundColor() : FColor(55, 55, 55);
}

void FEditorViewportClient::SetCameraSetup(
    const FVector& LocationForOrbiting,
    const FRotator& InOrbitRotation,
    const FVector& InOrbitZoom,
    const FVector& InOrbitLookAt,
    const FVector& InViewLocation,
    const FRotator& InViewRotation)
{
    if (bUsingOrbitCamera)
    {
        SetViewRotation(InOrbitRotation);
        SetViewLocation(InViewLocation + InOrbitZoom);
        SetLookAtLocation(InOrbitLookAt);
    }
    else
    {
        SetViewLocation(InViewLocation);
        SetViewRotation(InViewRotation);
    }

    // Save settings for toggling between orbit and unlocked camera
    DefaultOrbitLocation = InViewLocation;
    DefaultOrbitRotation = InOrbitRotation;
    DefaultOrbitZoom     = InOrbitZoom;
    DefaultOrbitLookAt   = InOrbitLookAt;
}

// Determines which axis InKey and InDelta most refer to and returns
// a corresponding FVector.  This vector represents the mouse movement
// translated into the viewports/widgets axis space.
//
// @param InNudge		If 1, this delta is coming from a keyboard nudge and not the mouse

FVector FEditorViewportClient::TranslateDelta(FKey InKey, float InDelta, bool InNudge)
{
    const bool LeftMouseButtonDown  = Viewport->KeyState(EKeys::LeftMouseButton);
    const bool RightMouseButtonDown = Viewport->KeyState(EKeys::RightMouseButton);
    const bool bIsUsingTrackpad     = FSlateApplication::Get().IsUsingTrackpad();

    FVector vec(0.0f, 0.0f, 0.0f);

    float X = InKey == EKeys::MouseX ? InDelta : 0.f;
    float Y = InKey == EKeys::MouseY ? InDelta : 0.f;

    switch (GetViewportType())
    {
        case LVT_OrthoXY:
        case LVT_OrthoXZ:
        case LVT_OrthoYZ:
        case LVT_OrthoNegativeXY:
        case LVT_OrthoNegativeXZ:
        case LVT_OrthoNegativeYZ: {
            LastMouseX += X;
            LastMouseY -= Y;

            if ((X != 0.0f) || (Y != 0.0f))
            {
                MarkMouseMovedSinceClick();
            }

            // only invert x,y if we're moving the camera
            if (ShouldUseMoveCanvasMovement())
            {
                if (Widget->GetCurrentAxis() == EAxisList::None)
                {
                    X = -X;
                    Y = -Y;
                }
            }

            // update the position
            Viewport->SetSoftwareCursorPosition(FVector2D(LastMouseX, LastMouseY));
            // UE_LOG(LogEditorViewport, Log, *FString::Printf( TEXT("can:%d %d") , LastMouseX , LastMouseY ));
            // change to grab hand
            SetRequiredCursorOverride(true, EMouseCursor::CardinalCross);
            // update and apply cursor visibility
            UpdateAndApplyCursorVisibility();

            FWidget::EWidgetMode WidgetMode = GetWidgetMode();
            bool bIgnoreOrthoScaling        = (WidgetMode == FWidget::WM_Scale) && (Widget->GetCurrentAxis() != EAxisList::None);

            if (InNudge || bIgnoreOrthoScaling)
            {
                vec = FVector(X, Y, 0.f);
            }
            else
            {
                const float UnitsPerPixel = GetOrthoUnitsPerPixel(Viewport);
                vec                       = FVector(X * UnitsPerPixel, Y * UnitsPerPixel, 0.f);

                if (Widget->GetCurrentAxis() == EAxisList::None)
                {
                    switch (GetViewportType())
                    {
                        case LVT_OrthoXY:
                            vec.Y *= -1.0f;
                            break;
                        case LVT_OrthoXZ:
                            vec = FVector(X * UnitsPerPixel, 0.f, Y * UnitsPerPixel);
                            break;
                        case LVT_OrthoYZ:
                            vec = FVector(0.f, X * UnitsPerPixel, Y * UnitsPerPixel);
                            break;
                        case LVT_OrthoNegativeXY:
                            vec = FVector(-X * UnitsPerPixel, -Y * UnitsPerPixel, 0.0f);
                            break;
                        case LVT_OrthoNegativeXZ:
                            vec = FVector(-X * UnitsPerPixel, 0.f, Y * UnitsPerPixel);
                            break;
                        case LVT_OrthoNegativeYZ:
                            vec = FVector(0.f, -X * UnitsPerPixel, Y * UnitsPerPixel);
                            break;
                        case LVT_OrthoFreelook:
                        case LVT_Perspective:
                            break;
                    }
                }
            }
        }
        break;

        case LVT_OrthoFreelook:  //@TODO: CAMERA: Not sure what to do here
        case LVT_Perspective:
            // Update the software cursor position
            Viewport->SetSoftwareCursorPosition(FVector2D(Viewport->GetMouseX(), Viewport->GetMouseY()));
            vec = FVector(X, Y, 0.f);
            break;

        default:
            check(0);  // Unknown viewport type
            break;
    }

    if (IsOrtho() && ((LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown) && Y != 0.f)
    {
        vec = FVector(0, 0, Y);
    }

    return vec;
}

bool FEditorViewportClient::InputAxis(FViewport* InViewport, int32 ControllerId, FKey Key, float Delta, float DeltaTime, int32 NumSamples, bool bGamepad)
{
    if (bDisableInput)
    {
        return true;
    }

    // Let the current mode have a look at the input before reacting to it.
    if (ModeTools->InputAxis(this, Viewport, ControllerId, Key, Delta, DeltaTime))
    {
        return true;
    }

    const bool bMouseButtonDown = InViewport->KeyState(EKeys::LeftMouseButton) || InViewport->KeyState(EKeys::MiddleMouseButton) || InViewport->KeyState(EKeys::RightMouseButton);
    const bool bLightMoveDown   = InViewport->KeyState(EKeys::L);

    // Look at which axis is being dragged and by how much
    const float DragX = (Key == EKeys::MouseX) ? Delta : 0.f;
    const float DragY = (Key == EKeys::MouseY) ? Delta : 0.f;

    if (bLightMoveDown && bMouseButtonDown && PreviewScene)
    {
        // Adjust the preview light direction
        FRotator LightDir = PreviewScene->GetLightDirection();

        LightDir.Yaw += -DragX * EditorViewportClient::LightRotSpeed;
        LightDir.Pitch += -DragY * EditorViewportClient::LightRotSpeed;

        PreviewScene->SetLightDirection(LightDir);

        // Remember that we adjusted it for the visualization
        MovingPreviewLightTimer          = PreviewLightConstants::MovingPreviewLightTimerDuration;
        MovingPreviewLightSavedScreenPos = FVector2D(LastMouseX, LastMouseY);

        Invalidate();
    }
    else
    {
        /**Save off axis commands for future camera work*/
        FCachedJoystickState* JoystickState = GetJoystickState(ControllerId);
        if (JoystickState)
        {
            JoystickState->AxisDeltaValues.Add(Key, Delta);
        }

        if (bIsTracking)
        {
            // Accumulate and snap the mouse movement since the last mouse button click.
            MouseDeltaTracker->AddDelta(this, Key, Delta, 0);
        }
    }

    // If we are using a drag tool, paint the viewport so we can see it update.
    if (MouseDeltaTracker->UsingDragTool())
    {
        Invalidate(false, false);
    }

    return true;
}

static float AdjustGestureCameraRotation(float Delta, float AdjustLimit, float DeltaCutoff)
{
    const float AbsDelta = FMath::Abs(Delta);
    const float Scale    = AbsDelta * (1.0f / AdjustLimit);
    if (AbsDelta > 0.0f && AbsDelta <= AdjustLimit)
    {
        return Delta * Scale;
    }
    const bool bIsUsingTrackpad = FSlateApplication::Get().IsUsingTrackpad();
    return bIsUsingTrackpad ? Delta : FMath::Clamp(Delta, -DeltaCutoff, DeltaCutoff);
}

bool FEditorViewportClient::InputGesture(FViewport* InViewport, EGestureEvent GestureType, const FVector2D& GestureDelta, bool bIsDirectionInvertedFromDevice)
{
    if (bDisableInput)
    {
        return true;
    }

    const FRotator& ViewRotation                         = GetViewRotation();

    const bool LeftMouseButtonDown                       = InViewport->KeyState(EKeys::LeftMouseButton);
    const bool RightMouseButtonDown                      = InViewport->KeyState(EKeys::RightMouseButton);

    const ELevelViewportType LevelViewportType           = GetViewportType();

    const ULevelEditorViewportSettings* ViewportSettings = GetDefault<ULevelEditorViewportSettings>();

    switch (LevelViewportType)
    {
        case LVT_OrthoXY:
        case LVT_OrthoXZ:
        case LVT_OrthoYZ:
        case LVT_OrthoNegativeXY:
        case LVT_OrthoNegativeXZ:
        case LVT_OrthoNegativeYZ: {
            if (GestureType == EGestureEvent::Scroll && !LeftMouseButtonDown && !RightMouseButtonDown)
            {
                const float UnitsPerPixel                      = GetOrthoUnitsPerPixel(InViewport);

                const EScrollGestureDirection DirectionSetting = GetDefault<ULevelEditorViewportSettings>()->ScrollGestureDirectionForOrthoViewports;
                const bool bUseDirectionInvertedFromDevice     = DirectionSetting == EScrollGestureDirection::Natural || (DirectionSetting == EScrollGestureDirection::UseSystemSetting && bIsDirectionInvertedFromDevice);

                // GestureDelta is in window pixel coords.  Adjust for ortho units.
                const FVector2D AdjustedGestureDelta = (bUseDirectionInvertedFromDevice == bIsDirectionInvertedFromDevice ? GestureDelta : -GestureDelta) * UnitsPerPixel;

                switch (LevelViewportType)
                {
                    case LVT_OrthoXY:
                        CurrentGestureDragDelta += FVector(-AdjustedGestureDelta.X, -AdjustedGestureDelta.Y, 0);
                        break;
                    case LVT_OrthoXZ:
                        CurrentGestureDragDelta += FVector(-AdjustedGestureDelta.X, 0, AdjustedGestureDelta.Y);
                        break;
                    case LVT_OrthoYZ:
                        CurrentGestureDragDelta += FVector(0, -AdjustedGestureDelta.X, AdjustedGestureDelta.Y);
                        break;
                    case LVT_OrthoNegativeXY:
                        CurrentGestureDragDelta += FVector(AdjustedGestureDelta.X, -AdjustedGestureDelta.Y, 0);
                        break;
                    case LVT_OrthoNegativeXZ:
                        CurrentGestureDragDelta += FVector(AdjustedGestureDelta.X, 0, AdjustedGestureDelta.Y);
                        break;
                    case LVT_OrthoNegativeYZ:
                        CurrentGestureDragDelta += FVector(0, AdjustedGestureDelta.X, AdjustedGestureDelta.Y);
                        break;
                    case LVT_OrthoFreelook:
                    case LVT_Perspective:
                        break;
                }

                FEditorViewportStats::Used(FEditorViewportStats::CAT_ORTHOGRAPHIC_GESTURE_SCROLL);
            }
            else if (GestureType == EGestureEvent::Magnify)
            {
                OnOrthoZoom(FInputEventState(InViewport, EKeys::MouseScrollDown, IE_Released), -10.0f * GestureDelta.X);
                FEditorViewportStats::Used(FEditorViewportStats::CAT_ORTHOGRAPHIC_GESTURE_MAGNIFY);
            }
        }
        break;

        case LVT_Perspective:
        case LVT_OrthoFreelook: {
            if (GestureType == EGestureEvent::Scroll)
            {
                const EScrollGestureDirection DirectionSetting = GetDefault<ULevelEditorViewportSettings>()->ScrollGestureDirectionFor3DViewports;
                const bool bUseDirectionInvertedFromDevice     = DirectionSetting == EScrollGestureDirection::Natural || (DirectionSetting == EScrollGestureDirection::UseSystemSetting && bIsDirectionInvertedFromDevice);
                const FVector2D AdjustedGestureDelta           = bUseDirectionInvertedFromDevice == bIsDirectionInvertedFromDevice ? GestureDelta : -GestureDelta;

                if (LeftMouseButtonDown)
                {
                    // Pan left/right/up/down

                    CurrentGestureDragDelta.X += AdjustedGestureDelta.X * -FMath::Sin(ViewRotation.Yaw * PI / 180.f);
                    CurrentGestureDragDelta.Y += AdjustedGestureDelta.X * FMath::Cos(ViewRotation.Yaw * PI / 180.f);
                    CurrentGestureDragDelta.Z += -AdjustedGestureDelta.Y;
                }
                else
                {
                    // Change viewing angle

                    CurrentGestureRotDelta.Yaw += AdjustGestureCameraRotation(AdjustedGestureDelta.X, 20.0f, 35.0f) * -0.35f;
                    CurrentGestureRotDelta.Pitch += AdjustGestureCameraRotation(AdjustedGestureDelta.Y, 20.0f, 35.0f) * 0.35f;
                }

                FEditorViewportStats::Used(FEditorViewportStats::CAT_ORTHOGRAPHIC_GESTURE_SCROLL);
            }
            else if (GestureType == EGestureEvent::Magnify)
            {
                GestureMoveForwardBackwardImpulse = GestureDelta.X * 4.0f;
            }
        }
        break;

        default:
            // Not a 3D viewport receiving this gesture.  Could be a canvas window.  Bail out.
            return false;
    }

    // mark "externally moved" so context menu doesn't come up
    MouseDeltaTracker->SetExternalMovement();

    return true;
}

void FEditorViewportClient::UpdateGestureDelta()
{
    if (CurrentGestureDragDelta != FVector::ZeroVector || CurrentGestureRotDelta != FRotator::ZeroRotator)
    {
        MoveViewportCamera(CurrentGestureDragDelta, CurrentGestureRotDelta, false);

        Invalidate(true, true);

        CurrentGestureDragDelta = FVector::ZeroVector;
        CurrentGestureRotDelta  = FRotator::ZeroRotator;
    }
}

// Converts a generic movement delta into drag/rotation deltas based on the viewport and keys held down

void FEditorViewportClient::ConvertMovementToDragRot(const FVector& InDelta,
                                                     FVector& InDragDelta,
                                                     FRotator& InRotDelta) const
{
    const FRotator& ViewRotation     = GetViewRotation();

    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton);
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton);
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton);
    const bool bIsUsingTrackpad      = FSlateApplication::Get().IsUsingTrackpad();

    InDragDelta                      = FVector::ZeroVector;
    InRotDelta                       = FRotator::ZeroRotator;

    switch (GetViewportType())
    {
        case LVT_OrthoXY:
        case LVT_OrthoXZ:
        case LVT_OrthoYZ:
        case LVT_OrthoNegativeXY:
        case LVT_OrthoNegativeXZ:
        case LVT_OrthoNegativeYZ: {
            if ((LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown)
            {
                // Both mouse buttons change the ortho viewport zoom.
                InDragDelta = FVector(0, 0, InDelta.Z);
            }
            else if (RightMouseButtonDown)
            {
                // @todo: set RMB to move opposite to the direction of drag, in other words "grab and pull".
                InDragDelta = InDelta;
            }
            else if (LeftMouseButtonDown)
            {
                // LMB moves in the direction of the drag.
                InDragDelta = InDelta;
            }
        }
        break;

        case LVT_Perspective:
        case LVT_OrthoFreelook: {
            const ULevelEditorViewportSettings* ViewportSettings = GetDefault<ULevelEditorViewportSettings>();

            if (LeftMouseButtonDown && !RightMouseButtonDown)
            {
                // Move forward and yaw

                InDragDelta.X  = InDelta.Y * FMath::Cos(ViewRotation.Yaw * PI / 180.f);
                InDragDelta.Y  = InDelta.Y * FMath::Sin(ViewRotation.Yaw * PI / 180.f);

                InRotDelta.Yaw = InDelta.X * ViewportSettings->MouseSensitivty;
            }
            else if (MiddleMouseButtonDown || bIsUsingTrackpad || ((LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown))
            {
                // Pan left/right/up/down
                const bool bInvert = !bIsUsingTrackpad && MiddleMouseButtonDown && GetDefault<ULevelEditorViewportSettings>()->bInvertMiddleMousePan;

                float Direction    = bInvert ? 1 : -1;
                InDragDelta.X      = InDelta.X * Direction * FMath::Sin(ViewRotation.Yaw * PI / 180.f);
                InDragDelta.Y      = InDelta.X * -Direction * FMath::Cos(ViewRotation.Yaw * PI / 180.f);
                InDragDelta.Z      = -Direction * InDelta.Y;
            }
            else if (RightMouseButtonDown && !LeftMouseButtonDown)
            {
                // Change viewing angle

                // inverting orbit axis is handled elsewhere
                const bool bInvertY = !ShouldOrbitCamera() && GetDefault<ULevelEditorViewportSettings>()->bInvertMouseLookYAxis;
                float Direction     = bInvertY ? -1 : 1;

                InRotDelta.Yaw      = InDelta.X * ViewportSettings->MouseSensitivty;
                InRotDelta.Pitch    = InDelta.Y * ViewportSettings->MouseSensitivty * Direction;
            }
        }
        break;

        default:
            check(0);  // unknown viewport type
            break;
    }
}

void FEditorViewportClient::ConvertMovementToOrbitDragRot(const FVector& InDelta,
                                                          FVector& InDragDelta,
                                                          FRotator& InRotDelta) const
{
    const FRotator& ViewRotation     = GetViewRotation();

    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton);
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton);
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton);
    const bool bIsUsingTrackpad      = FSlateApplication::Get().IsUsingTrackpad();

    InDragDelta                      = FVector::ZeroVector;
    InRotDelta                       = FRotator::ZeroRotator;

    const float YawRadians           = FMath::DegreesToRadians(ViewRotation.Yaw);

    switch (GetViewportType())
    {
        case LVT_OrthoXY:
        case LVT_OrthoXZ:
        case LVT_OrthoYZ:
        case LVT_OrthoNegativeXY:
        case LVT_OrthoNegativeXZ:
        case LVT_OrthoNegativeYZ: {
            if ((LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown)
            {
                // Change ortho zoom.
                InDragDelta = FVector(0, 0, InDelta.Z);
            }
            else if (RightMouseButtonDown)
            {
                // Move camera.
                InDragDelta = InDelta;
            }
            else if (LeftMouseButtonDown)
            {
                // Move actors.
                InDragDelta = InDelta;
            }
        }
        break;

        case LVT_Perspective: {
            const ULevelEditorViewportSettings* ViewportSettings = GetDefault<ULevelEditorViewportSettings>();

            if (IsOrbitRotationMode(Viewport))
            {
                const bool bInvertY = GetDefault<ULevelEditorViewportSettings>()->bInvertOrbitYAxis;
                float Direction     = bInvertY ? -1 : 1;

                // Change the viewing angle
                InRotDelta.Yaw   = InDelta.X * ViewportSettings->MouseSensitivty;
                InRotDelta.Pitch = InDelta.Y * ViewportSettings->MouseSensitivty * Direction;
            }
            else if (IsOrbitPanMode(Viewport))
            {
                // Pan left/right/up/down
                InDragDelta.X = InDelta.X * -FMath::Sin(YawRadians);
                InDragDelta.Y = InDelta.X * FMath::Cos(YawRadians);
                InDragDelta.Z = InDelta.Y;
            }
            else if (IsOrbitZoomMode(Viewport))
            {
                // Zoom in and out.
                InDragDelta.X = InDelta.Y * FMath::Cos(YawRadians);
                InDragDelta.Y = InDelta.Y * FMath::Sin(YawRadians);
            }
        }
        break;

        default:
            check(0);  // unknown viewport type
            break;
    }
}

bool FEditorViewportClient::ShouldPanOrDollyCamera() const
{
    const bool bIsCtrlDown            = IsCtrlPressed();

    const bool bLeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton);
    const bool bRightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton);
    const bool bIsMarqueeSelect       = IsOrtho() && bLeftMouseButtonDown;

    const bool bOrthoRotateObjectMode = IsOrtho() && IsCtrlPressed() && bRightMouseButtonDown && !bLeftMouseButtonDown;
    // Pan the camera if not marquee selecting or the left and right mouse buttons are down
    return !bOrthoRotateObjectMode && !bIsCtrlDown && (!bIsMarqueeSelect || (bLeftMouseButtonDown && bRightMouseButtonDown));
}

TSharedPtr<FDragTool> FEditorViewportClient::MakeDragTool(EDragTool::Type)
{
    return MakeShareable(new FDragTool(GetModeTools()));
}

bool FEditorViewportClient::CanUseDragTool() const
{
    return !ShouldOrbitCamera() && (GetCurrentWidgetAxis() == EAxisList::None) && ((ModeTools == nullptr) || ModeTools->AllowsViewportDragTool());
}

bool FEditorViewportClient::ShouldOrbitCamera() const
{
    if (bCameraLock)
    {
        return true;
    }
    else
    {
        bool bDesireOrbit = false;

        if (!GetDefault<ULevelEditorViewportSettings>()->bUseUE3OrbitControls)
        {
            bDesireOrbit = IsAltPressed() && !IsCtrlPressed() && !IsShiftPressed();
        }
        else
        {
            bDesireOrbit = Viewport->KeyState(EKeys::U) || Viewport->KeyState(EKeys::L);
        }

        return bDesireOrbit && !IsFlightCameraInputModeActive() && !IsOrtho();
    }
}

/** Returns true if perspective flight camera input mode is currently active in this viewport */
bool FEditorViewportClient::IsFlightCameraInputModeActive() const
{
    if ((Viewport != NULL) && IsPerspective())
    {
        if (CameraController != NULL)
        {
            const bool bLeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) && !bLockFlightCamera;
            const bool bMiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton);
            const bool bRightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton);
            const bool bIsUsingTrackpad       = FSlateApplication::Get().IsUsingTrackpad();

            const bool bIsNonOrbitMiddleMouse = bMiddleMouseButtonDown && !IsAltPressed();

            const bool bIsMouseLooking =
                bIsTracking &&
                Widget->GetCurrentAxis() == EAxisList::None &&
                (bLeftMouseButtonDown || bMiddleMouseButtonDown || bRightMouseButtonDown || bIsUsingTrackpad) &&
                !IsCtrlPressed() && (GetDefault<ULevelEditorViewportSettings>()->FlightCameraControlExperimentalNavigation || !IsShiftPressed()) && !IsAltPressed();

            return bIsMouseLooking;
        }
    }

    return false;
}

bool FEditorViewportClient::IsMovingCamera() const
{
    return bUsingOrbitCamera || IsFlightCameraActive();
}

/** True if the window is maximized or floating */
bool FEditorViewportClient::IsVisible() const
{
    bool bIsVisible = false;

    if (VisibilityDelegate.IsBound())
    {
        // Call the visibility delegate to see if our parent viewport and layout configuration says we arevisible
        bIsVisible = VisibilityDelegate.Execute();
    }

    return bIsVisible;
}

void FEditorViewportClient::GetViewportDimensions(FIntPoint& OutOrigin, FIntPoint& Outize)
{
    OutOrigin = FIntPoint(0, 0);
    if (Viewport != NULL)
    {
        Outize.X = Viewport->GetSizeXY().X;
        Outize.Y = Viewport->GetSizeXY().Y;
    }
    else
    {
        Outize = FIntPoint(0, 0);
    }
}

void FEditorViewportClient::UpdateAndApplyCursorVisibility()
{
    UpdateRequiredCursorVisibility();
    ApplyRequiredCursorVisibility();
}

void FEditorViewportClient::UpdateRequiredCursorVisibility()
{
    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) ? true : false;
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton) ? true : false;
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton) ? true : false;
    const bool bMouseButtonDown      = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);
    const bool bIsUsingTrackpad      = FSlateApplication::Get().IsUsingTrackpad();

    bool AltDown                     = IsAltPressed();
    bool ShiftDown                   = IsShiftPressed();
    bool ControlDown                 = IsCtrlPressed();

    bool bOverrideCursorVisibility   = false;
    bool bHardwareCursorVisible      = false;
    bool bSoftwareCursorVisible      = false;
    if (ModeTools->GetOverrideCursorVisibility(bOverrideCursorVisibility, bHardwareCursorVisible, bSoftwareCursorVisible))
    {
        if (bOverrideCursorVisibility)
        {
            SetRequiredCursor(bHardwareCursorVisible, bSoftwareCursorVisible);
            return;
        }
    }

    if (GetViewportType() == LVT_None)
    {
        SetRequiredCursor(true, false);
        return;
    }

    // if we're using the new move canvas mode, we're in an ortho viewport, and the mouse is down
    if (IsOrtho() && bMouseButtonDown && !MouseDeltaTracker->UsingDragTool())
    {
        // Translating an object, but NOT moving the camera AND the object (shift)
        if ((AltDown == false && ShiftDown == false && (LeftMouseButtonDown ^ RightMouseButtonDown)) &&
            ((GetWidgetMode() == FWidget::WM_Translate && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_TranslateRotateZ && Widget->GetCurrentAxis() != EAxisList::ZRotation && Widget->GetCurrentAxis() != EAxisList::None) ||
             (GetWidgetMode() == FWidget::WM_2D && Widget->GetCurrentAxis() != EAxisList::Rotate2D && Widget->GetCurrentAxis() != EAxisList::None)))
        {
            SetRequiredCursor(false, true);
            SetRequiredCursorOverride(true, EMouseCursor::CardinalCross);
            return;
        }

        if (GetDefault<ULevelEditorViewportSettings>()->bPanMovesCanvas && RightMouseButtonDown)
        {
            bool bMovingCamera    = GetCurrentWidgetAxis() == EAxisList::None;
            bool bIsZoomingCamera = bMovingCamera && (LeftMouseButtonDown || bIsUsingTrackpad);
            // moving camera without  zooming
            if (bMovingCamera && !bIsZoomingCamera)
            {
                // Always turn the hardware cursor on before turning the software cursor off
                // so the hardware cursor will be be set where the software cursor was
                SetRequiredCursor(!bHasMouseMovedSinceClick, bHasMouseMovedSinceClick);
                SetRequiredCursorOverride(true, EMouseCursor::GrabHand);
                return;
            }
            SetRequiredCursor(false, false);
            return;
        }
    }

    // if Absolute Translation or arc rotate and not just moving the camera around
    if (IsUsingAbsoluteTranslation(true) && !MouseDeltaTracker->UsingDragTool())
    {
        // If we are dragging something we should hide the hardware cursor and show the s/w one
        SetRequiredCursor(false, true);
        SetRequiredCursorOverride(true, EMouseCursor::CardinalCross);
    }
    else
    {
        // Calc the raw delta from the mouse since we started dragging to detect if there was any movement
        FVector RawMouseDelta = MouseDeltaTracker->GetRawDelta();

        if (bMouseButtonDown && (RawMouseDelta.SizeSquared() >= MOUSE_CLICK_DRAG_DELTA || IsFlightCameraActive() || ShouldOrbitCamera()) && !MouseDeltaTracker->UsingDragTool())
        {
            // current system - do not show cursor when mouse is down
            SetRequiredCursor(false, false);
            return;
        }

        if (MouseDeltaTracker->UsingDragTool())
        {
            RequiredCursorVisibiltyAndAppearance.bOverrideAppearance = false;
        }

        SetRequiredCursor(true, false);
    }
}

void FEditorViewportClient::SetRequiredCursor(const bool bHardwareCursorVisible, const bool bSoftwareCursorVisible)
{
    RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible = bHardwareCursorVisible;
    RequiredCursorVisibiltyAndAppearance.bSoftwareCursorVisible = bSoftwareCursorVisible;
}

void FEditorViewportClient::ApplyRequiredCursorVisibility(bool bUpdateSoftwareCursorPostion)
{
    if (RequiredCursorVisibiltyAndAppearance.bDontResetCursor == true)
    {
        Viewport->SetPreCaptureMousePosFromSlateCursor();
    }
    bool bOldCursorVisibility         = Viewport->IsCursorVisible();
    bool bOldSoftwareCursorVisibility = Viewport->IsSoftwareCursorVisible();

    Viewport->ShowCursor(RequiredCursorVisibiltyAndAppearance.bHardwareCursorVisible);
    Viewport->ShowSoftwareCursor(RequiredCursorVisibiltyAndAppearance.bSoftwareCursorVisible);
    if (bUpdateSoftwareCursorPostion == true)
    {
        // if we made the software cursor visible set its position
        if (bOldSoftwareCursorVisibility != Viewport->IsSoftwareCursorVisible())
        {
            Viewport->SetSoftwareCursorPosition(FVector2D(Viewport->GetMouseX(), Viewport->GetMouseY()));
        }
    }
}

void FEditorViewportClient::SetRequiredCursorOverride(bool WantOverride, EMouseCursor::Type RequiredCursor)
{
    RequiredCursorVisibiltyAndAppearance.bOverrideAppearance = WantOverride;
    RequiredCursorVisibiltyAndAppearance.RequiredCursor      = RequiredCursor;
}

void FEditorViewportClient::SetWidgetModeOverride(FWidget::EWidgetMode InWidgetMode)
{
    ModeTools->SetWidgetModeOverride(InWidgetMode);
}

EAxisList::Type FEditorViewportClient::GetCurrentWidgetAxis() const
{
    return Widget->GetCurrentAxis();
}

void FEditorViewportClient::SetCurrentWidgetAxis(EAxisList::Type InAxis)
{
    Widget->SetCurrentAxis(InAxis);
    ModeTools->SetCurrentWidgetAxis(InAxis);
}

void FEditorViewportClient::AdjustTransformWidgetSize(const int32 SizeDelta)
{
    ULevelEditorViewportSettings& ViewportSettings = *GetMutableDefault<ULevelEditorViewportSettings>();
    ViewportSettings.TransformWidgetSizeAdjustment = FMath::Clamp(ViewportSettings.TransformWidgetSizeAdjustment + SizeDelta, -10, 150);
    ViewportSettings.PostEditChange();
}

float FEditorViewportClient::GetNearClipPlane() const
{
    return (NearPlane < 0.0f) ? GNearClippingPlane : NearPlane;
}

void FEditorViewportClient::OverrideNearClipPlane(float InNearPlane)
{
    NearPlane = InNearPlane;
}

float FEditorViewportClient::GetFarClipPlaneOverride() const
{
    return FarPlane;
}

void FEditorViewportClient::OverrideFarClipPlane(const float InFarPlane)
{
    FarPlane = InFarPlane;
}

float FEditorViewportClient::GetSceneDepthAtLocation(int32 X, int32 Y)
{
    // #todo: in the future we will just sample the depth buffer
    return 0.f;
}

FVector FEditorViewportClient::GetHitProxyObjectLocation(int32 X, int32 Y)
{
    // #todo: for now we are just getting the actor and using its location for
    // depth. in the future we will just sample the depth buffer
    HHitProxy* const HitProxy = Viewport->GetHitProxy(X, Y);
    if (HitProxy && HitProxy->IsA(HActor::StaticGetType()))
    {
        HActor* const ActorHit = static_cast<HActor*>(HitProxy);

        // dist to component will be more reliable than dist to actor
        if (ActorHit->PrimComponent != nullptr)
        {
            return ActorHit->PrimComponent->GetComponentLocation();
        }

        if (ActorHit->Actor != nullptr)
        {
            return ActorHit->Actor->GetActorLocation();
        }
    }

    return FVector::ZeroVector;
}

void FEditorViewportClient::ShowWidget(const bool bShow)
{
    bShowWidget = bShow;
}

void FEditorViewportClient::MoveViewportCamera(const FVector& InDrag, const FRotator& InRot, bool bDollyCamera)
{
    switch (GetViewportType())
    {
        case LVT_OrthoXY:
        case LVT_OrthoXZ:
        case LVT_OrthoYZ:
        case LVT_OrthoNegativeXY:
        case LVT_OrthoNegativeXZ:
        case LVT_OrthoNegativeYZ: {
            const bool LeftMouseButtonDown  = Viewport->KeyState(EKeys::LeftMouseButton);
            const bool RightMouseButtonDown = Viewport->KeyState(EKeys::RightMouseButton);
            const bool bIsUsingTrackpad     = FSlateApplication::Get().IsUsingTrackpad();

            if ((LeftMouseButtonDown || bIsUsingTrackpad) && RightMouseButtonDown)
            {
                SetOrthoZoom(GetOrthoZoom() + (GetOrthoZoom() / CAMERA_ZOOM_DAMPEN) * InDrag.Z);
                SetOrthoZoom(FMath::Clamp<float>(GetOrthoZoom(), GetMinimumOrthoZoom(), MAX_ORTHOZOOM));
            }
            else
            {
                SetViewLocation(GetViewLocation() + InDrag);
            }

            // Update any linked orthographic viewports.
            UpdateLinkedOrthoViewports();
        }
        break;

        case LVT_OrthoFreelook:
            //@TODO: CAMERA: Not sure how to handle this
            break;

        case LVT_Perspective: {
            // If the flight camera is active, we'll update the rotation impulse data for that instead
            // of rotating the camera ourselves here
            if (IsFlightCameraInputModeActive() && CameraController->GetConfig().bUsePhysicsBasedRotation)
            {
                const ULevelEditorViewportSettings* ViewportSettings = GetDefault<ULevelEditorViewportSettings>();

                // NOTE: We damp the rotation for impulse input since the camera controller will
                //	apply its own rotation speed
                const float VelModRotSpeed = 900.0f;
                const FVector RotEuler     = InRot.Euler();

                CameraUserImpulseData->RotateRollVelocityModifier += VelModRotSpeed * RotEuler.X / ViewportSettings->MouseSensitivty;
                CameraUserImpulseData->RotatePitchVelocityModifier += VelModRotSpeed * RotEuler.Y / ViewportSettings->MouseSensitivty;
                CameraUserImpulseData->RotateYawVelocityModifier += VelModRotSpeed * RotEuler.Z / ViewportSettings->MouseSensitivty;
            }
            else
            {
                MoveViewportPerspectiveCamera(InDrag, InRot, bDollyCamera);
            }
        }
        break;
    }
}

bool FEditorViewportClient::ShouldLockPitch() const
{
    return CameraController->GetConfig().bLockedPitch;
}

void FEditorViewportClient::CheckHoveredHitProxy(HHitProxy* HoveredHitProxy)
{
    const EAxisList::Type SaveAxis   = Widget->GetCurrentAxis();
    EAxisList::Type NewAxis          = EAxisList::None;

    const bool LeftMouseButtonDown   = Viewport->KeyState(EKeys::LeftMouseButton) ? true : false;
    const bool MiddleMouseButtonDown = Viewport->KeyState(EKeys::MiddleMouseButton) ? true : false;
    const bool RightMouseButtonDown  = Viewport->KeyState(EKeys::RightMouseButton) ? true : false;
    const bool bMouseButtonDown      = (LeftMouseButtonDown || MiddleMouseButtonDown || RightMouseButtonDown);

    // Change the mouse cursor if the user is hovering over something they can interact with.
    if (HoveredHitProxy)
    {
        if (HoveredHitProxy->IsA(HWidgetAxis::StaticGetType()) && !bUsingOrbitCamera && !bMouseButtonDown)
        {
            // In the case of the widget mode being overridden we can have a hit proxy
            // from the previous mode with an inappropriate axis for rotation.
            EAxisList::Type ProxyAxis = ((HWidgetAxis*)HoveredHitProxy)->Axis;
            if (!IsOrtho() || GetWidgetMode() != FWidget::WM_Rotate || ProxyAxis == EAxisList::X || ProxyAxis == EAxisList::Y || ProxyAxis == EAxisList::Z)
            {
                NewAxis = ProxyAxis;
            }
            else
            {
                switch (GetViewportType())
                {
                    case LVT_OrthoXY:
                    case LVT_OrthoNegativeXY:
                        NewAxis = EAxisList::Z;
                        break;
                    case LVT_OrthoXZ:
                    case LVT_OrthoNegativeXZ:
                        NewAxis = EAxisList::Y;
                        break;
                    case LVT_OrthoYZ:
                    case LVT_OrthoNegativeYZ:
                        NewAxis = EAxisList::X;
                        break;
                    default:
                        break;
                }
            }
        }

        // If the current axis on the widget changed, repaint the viewport.
        if (NewAxis != SaveAxis)
        {
            SetCurrentWidgetAxis(NewAxis);

            Invalidate(false, false);
        }
    }
}

void FEditorViewportClient::ConditionalCheckHoveredHitProxy()
{
    // If it has been decided that there is more important things to do than check hit proxies, then don't check them.
    if (!bShouldCheckHitProxy || bWidgetAxisControlledByDrag == true)
    {
        return;
    }

    HHitProxy* HitProxy = Viewport->GetHitProxy(CachedMouseX, CachedMouseY);

    CheckHoveredHitProxy(HitProxy);

    // We need to set this to false here as if mouse is moved off viewport fast, it will keep doing CheckHoveredOverHitProxy for this viewport when it should not.
    bShouldCheckHitProxy = false;
}

/** Moves a perspective camera */
void FEditorViewportClient::MoveViewportPerspectiveCamera(const FVector& InDrag, const FRotator& InRot, bool bDollyCamera)
{
    check(IsPerspective());

    FVector ViewLocation  = GetViewLocation();
    FRotator ViewRotation = GetViewRotation();

    if (ShouldLockPitch())
    {
        // Update camera Rotation
        ViewRotation += FRotator(InRot.Pitch, InRot.Yaw, InRot.Roll);

        // normalize to -180 to 180
        ViewRotation.Pitch = FRotator::NormalizeAxis(ViewRotation.Pitch);
        // Make sure its withing  +/- 90 degrees (minus a small tolerance to avoid numerical issues w/ camera orientation conversions later on).
        ViewRotation.Pitch = FMath::Clamp(ViewRotation.Pitch, -90.f + KINDA_SMALL_NUMBER, 90.f - KINDA_SMALL_NUMBER);
    }
    else
    {
        // when not constraining the pitch (matinee feature) we need to rotate differently to avoid a gimbal lock
        const FRotator PitchRot(InRot.Pitch, 0, 0);
        const FRotator LateralRot(0, InRot.Yaw, InRot.Roll);

        // update lateral rotation
        ViewRotation += LateralRot;

        // update pitch separately using quaternions
        const FQuat ViewQuat   = ViewRotation.Quaternion();
        const FQuat PitchQuat  = PitchRot.Quaternion();
        const FQuat ResultQuat = ViewQuat * PitchQuat;

        // get our correctly rotated ViewRotation
        ViewRotation = ResultQuat.Rotator();
    }

    const float DistanceToCurrentLookAt  = FVector::Dist(GetViewLocation(), GetLookAtLocation());
    const float CameraSpeedDistanceScale = ShouldScaleCameraSpeedByDistance() ? FMath::Min(DistanceToCurrentLookAt / 1000.f, 1000.f) : 1.f;

    // Update camera Location
    ViewLocation += InDrag * CameraSpeedDistanceScale;

    if (!bDollyCamera)
    {
        const FQuat CameraOrientation = FQuat::MakeFromEuler(ViewRotation.Euler());
        FVector Direction             = CameraOrientation.RotateVector(FVector(1, 0, 0));

        SetLookAtLocation(ViewLocation + Direction * DistanceToCurrentLookAt);
    }

    SetViewLocation(ViewLocation);
    SetViewRotation(ViewRotation);

    if (bUsingOrbitCamera)
    {
        FVector LookAtPoint          = GetLookAtLocation();
        const float DistanceToLookAt = FVector::Dist(ViewLocation, LookAtPoint);

        SetViewLocationForOrbiting(LookAtPoint, DistanceToLookAt);
    }

    PerspectiveCameraMoved();
}

void FEditorViewportClient::EnableCameraLock(bool bEnable)
{
    bCameraLock = bEnable;

    if (bCameraLock)
    {
        SetViewLocation(DefaultOrbitLocation + DefaultOrbitZoom);
        SetViewRotation(DefaultOrbitRotation);
        SetLookAtLocation(DefaultOrbitLookAt);
    }
    else
    {
        ToggleOrbitCamera(false);
    }

    bUsingOrbitCamera = bCameraLock;
}

FCachedJoystickState* FEditorViewportClient::GetJoystickState(const uint32 InControllerID)
{
    FCachedJoystickState* CurrentState = JoystickStateMap.FindRef(InControllerID);
    if (CurrentState == NULL)
    {
        /** Create new joystick state for cached input*/
        CurrentState               = new FCachedJoystickState();
        CurrentState->JoystickType = 0;
        JoystickStateMap.Add(InControllerID, CurrentState);
    }

    return CurrentState;
}

void FEditorViewportClient::SetCameraLock()
{
    EnableCameraLock(!bCameraLock);
    Invalidate();
}

bool FEditorViewportClient::IsCameraLocked() const
{
    return bCameraLock;
}

void FEditorViewportClient::SetShowGrid()
{
    EngineShowFlags.SetGrid(!EngineShowFlags.Grid);
    if (FEngineAnalytics::IsAvailable())
    {
        FEngineAnalytics::GetProvider().RecordEvent(TEXT("Editor.Usage.StaticMesh.Toolbar"), TEXT("EngineShowFlags.Grid"), EngineShowFlags.Grid ? TEXT("True") : TEXT("False"));
    }
    Invalidate();
}

bool FEditorViewportClient::IsSetShowGridChecked() const
{
    return EngineShowFlags.Grid;
}

void FEditorViewportClient::SetShowBounds(bool bShow)
{
    EngineShowFlags.SetBounds(bShow);
}

void FEditorViewportClient::ToggleShowBounds()
{
    EngineShowFlags.SetBounds(!EngineShowFlags.Bounds);
    if (FEngineAnalytics::IsAvailable())
    {
        FEngineAnalytics::GetProvider().RecordEvent(TEXT("Editor.Usage.StaticMesh.Toolbar"), TEXT("Bounds"), FString::Printf(TEXT("%d"), EngineShowFlags.Bounds));
    }
    Invalidate();
}

bool FEditorViewportClient::IsSetShowBoundsChecked() const
{
    return EngineShowFlags.Bounds;
}

void FEditorViewportClient::UpdateHiddenCollisionDrawing()
{
    FSceneInterface* SceneInterface = GetScene();
    if (SceneInterface != nullptr)
    {
        UWorld* World = SceneInterface->GetWorld();
        if (World != nullptr)
        {
            // See if this is a collision view mode
            bool bCollisionMode = EngineShowFlags.Collision || EngineShowFlags.CollisionVisibility || EngineShowFlags.CollisionPawn;

            // Tell engine to create proxies for hidden components, so we can still draw collision
            if (World->bCreateRenderStateForHiddenComponentsWithCollsion != bCollisionMode)
            {
                World->bCreateRenderStateForHiddenComponentsWithCollsion = bCollisionMode;

                // Need to recreate scene proxies when this flag changes.
                FGlobalComponentRecreateRenderStateContext Recreate;
            }
        }
    }
}

void FEditorViewportClient::SetShowCollision()
{
    EngineShowFlags.SetCollision(!EngineShowFlags.Collision);
    UpdateHiddenCollisionDrawing();
    Invalidate();
}

bool FEditorViewportClient::IsSetShowCollisionChecked() const
{
    return EngineShowFlags.Collision;
}

void FEditorViewportClient::SetViewMode(EViewModeIndex InViewModeIndex)
{
    ViewModeParam     = -1;  // Reset value when the viewmode changes
    ViewModeParamName = NAME_None;
    ViewModeParamNameMap.Empty();

    if (IsPerspective())
    {
        if (InViewModeIndex == VMI_MaterialTextureScaleAccuracy)
        {
            FEditorBuildUtils::UpdateTextureStreamingMaterialBindings(GetWorld());
        }

        PerspViewModeIndex = InViewModeIndex;
        ApplyViewMode(PerspViewModeIndex, true, EngineShowFlags);
        bForcingUnlitForNewMap = false;
    }
    else
    {
        OrthoViewModeIndex = InViewModeIndex;
        ApplyViewMode(OrthoViewModeIndex, false, EngineShowFlags);
    }

    UpdateHiddenCollisionDrawing();
    Invalidate();
}

void FEditorViewportClient::SetViewModes(const EViewModeIndex InPerspViewModeIndex, const EViewModeIndex InOrthoViewModeIndex)
{
    PerspViewModeIndex = InPerspViewModeIndex;
    OrthoViewModeIndex = InOrthoViewModeIndex;

    if (IsPerspective())
    {
        ApplyViewMode(PerspViewModeIndex, true, EngineShowFlags);
    }
    else
    {
        ApplyViewMode(OrthoViewModeIndex, false, EngineShowFlags);
    }

    UpdateHiddenCollisionDrawing();
    Invalidate();
}

void FEditorViewportClient::SetViewModeParam(int32 InViewModeParam)
{
    ViewModeParam     = InViewModeParam;
    FName* BoundName  = ViewModeParamNameMap.Find(ViewModeParam);
    ViewModeParamName = BoundName ? *BoundName : FName();

    Invalidate();
}

bool FEditorViewportClient::IsViewModeParam(int32 InViewModeParam) const
{
    const FName* MappedName = ViewModeParamNameMap.Find(ViewModeParam);
    // Check if the param and names match. The param name only gets updated on click, while the map is built at menu creation.
    if (MappedName)
    {
        return ViewModeParam == InViewModeParam && ViewModeParamName == *MappedName;
    }
    else
    {
        return ViewModeParam == InViewModeParam && ViewModeParamName == NAME_None;
    }
}

EViewModeIndex FEditorViewportClient::GetViewMode() const
{
    return (IsPerspective()) ? PerspViewModeIndex : OrthoViewModeIndex;
}

void FEditorViewportClient::Invalidate(bool bInvalidateChildViews, bool bInvalidateHitProxies)
{
    if (Viewport)
    {
        if (bInvalidateHitProxies)
        {
            // Invalidate hit proxies and display pixels.
            Viewport->Invalidate();
        }
        else
        {
            // Invalidate only display pixels.
            Viewport->InvalidateDisplay();
        }

        // If this viewport is a view parent . . .
        if (bInvalidateChildViews &&
            ViewState.GetReference()->IsViewParent())
        {
            GEditor->InvalidateChildViewports(ViewState.GetReference(), bInvalidateHitProxies);
        }
    }
}

void FEditorViewportClient::MouseEnter(FViewport* InViewport, int32 x, int32 y)
{
    ModeTools->MouseEnter(this, Viewport, x, y);

    MouseMove(InViewport, x, y);

    PixelInspectorRealtimeManagement(this, true);
}

void FEditorViewportClient::MouseMove(FViewport* InViewport, int32 x, int32 y)
{
    check(IsInGameThread());

    CurrentMousePos = FIntPoint(x, y);

    // Let the current editor mode know about the mouse movement.
    ModeTools->MouseMove(this, Viewport, x, y);

    CachedLastMouseX = x;
    CachedLastMouseY = y;
}

void FEditorViewportClient::MouseLeave(FViewport* InViewport)
{
    check(IsInGameThread());

    ModeTools->MouseLeave(this, Viewport);

    CurrentMousePos = FIntPoint(-1, -1);

    FCommonViewportClient::MouseLeave(InViewport);

    PixelInspectorRealtimeManagement(this, false);
}

FViewportCursorLocation FEditorViewportClient::GetCursorWorldLocationFromMousePos()
{
    // Create the scene view context
    FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
                                           Viewport,
                                           GetScene(),
                                           EngineShowFlags)
                                           .SetRealtimeUpdate(IsRealtime()));

    // Calculate the scene view
    FSceneView* View = CalcSceneView(&ViewFamily);

    // Construct an FViewportCursorLocation which calculates world space postion from the scene view and mouse pos.
    return FViewportCursorLocation(View,
                                   this,
                                   Viewport->GetMouseX(),
                                   Viewport->GetMouseY());
}

void FEditorViewportClient::CapturedMouseMove(FViewport* InViewport, int32 InMouseX, int32 InMouseY)
{
    UpdateRequiredCursorVisibility();
    ApplyRequiredCursorVisibility();

    CapturedMouseMoves.Add(FIntPoint(InMouseX, InMouseY));

    // Let the current editor mode know about the mouse movement.
    if (ModeTools->CapturedMouseMove(this, InViewport, InMouseX, InMouseY))
    {
        return;
    }
}

void FEditorViewportClient::ProcessAccumulatedPointerInput(FViewport* InViewport)
{
    ModeTools->ProcessCapturedMouseMoves(this, InViewport, CapturedMouseMoves);
    CapturedMouseMoves.Reset();
}

void FEditorViewportClient::OpenScreenshot(FString SourceFilePath)
{
    FPlatformProcess::ExploreFolder(*(FPaths::GetPath(SourceFilePath)));
}

void FEditorViewportClient::TakeScreenshot(FViewport* InViewport, bool bInValidatViewport)
{
    FHighResScreenshotConfig& HighResScreenshotConfig = GetHighResScreenshotConfig();

    if (!ensure(HighResScreenshotConfig.ImageWriteQueue))
    {
        return;
    }

    // The old method for taking screenshots does this for us on mousedown, so we do not have
    //	to do this for all situations.
    if (bInValidatViewport)
    {
        // We need to invalidate the viewport in order to generate the correct pixel buffer for picking.
        Invalidate(false, true);
    }

    // Redraw the viewport so we don't end up with clobbered data from other viewports using the same frame buffer.
    InViewport->Draw();

    // Inform the user of the result of the operation
    FNotificationInfo Info(FText::GetEmpty());
    Info.ExpireDuration                          = 5.0f;
    Info.bUseSuccessFailIcons                    = false;
    Info.bUseLargeFont                           = false;

    TSharedPtr<SNotificationItem> SaveMessagePtr = FSlateNotificationManager::Get().AddNotification(Info);
    SaveMessagePtr->SetCompletionState(SNotificationItem::CS_Fail);

    TUniquePtr<FImageWriteTask> ImageTask = MakeUnique<FImageWriteTask>();

    {
        // Read the contents of the viewport into an array.
        TArray<FColor> RawPixels;
        RawPixels.SetNum(InViewport->GetSizeXY().X * InViewport->GetSizeXY().Y);
        if (!InViewport->ReadPixels(RawPixels))
        {
            // Failed to read the image from the viewport
            SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotFailedViewport", "Screenshot failed, unable to read image from viewport"));
            return;
        }

        TUniquePtr<TImagePixelData<FColor>> PixelData = MakeUnique<TImagePixelData<FColor>>(InViewport->GetSizeXY(), TArray64<FColor>(MoveTemp(RawPixels)));

        check(PixelData->IsDataWellFormed());
        ImageTask->PixelData = MoveTemp(PixelData);
    }

    // Ensure the alpha channel is full alpha (this happens on the background thread)
    ImageTask->PixelPreProcessors.Add(TAsyncAlphaWrite<FColor>(255));

    // Create screenshot folder if not already present.
    const FString& Directory = GetDefault<ULevelEditorMiscSettings>()->EditorScreenshotSaveDirectory.Path;
    if (!IFileManager::Get().MakeDirectory(*Directory, true))
    {
        // Failed to make save directory
        UE_LOG(LogEditorViewport, Warning, TEXT("Failed to create directory %s"), *FPaths::ConvertRelativePathToFull(Directory));
        SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotFailedFolder", "Screenshot capture failed, unable to create save directory (see log)"));
        return;
    }

    // Save the contents of the array to a bitmap file.
    HighResScreenshotConfig.SetHDRCapture(false);

    // Set the image task parameters
    ImageTask->Format             = EImageFormat::PNG;
    ImageTask->CompressionQuality = (int32)EImageCompressionQuality::Default;

    bool bGeneratedFilename       = FFileHelper::GenerateNextBitmapFilename(Directory / TEXT("ScreenShot"), TEXT("png"), ImageTask->Filename);
    if (!bGeneratedFilename)
    {
        SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotFailed_TooManyScreenshots", "Screenshot failed, too many screenshots in output directory"));
        return;
    }

    FString HyperLinkString = FPaths::ConvertRelativePathToFull(ImageTask->Filename);

    // Define the callback to be called on the main thread when the image has completed
    // This will be called regardless of whether the write succeeded or not, and will update
    // the text and completion state of the notification.
    ImageTask->OnCompleted = [HyperLinkString, SaveMessagePtr](bool bCompletedSuccessfully)
    {
        if (bCompletedSuccessfully)
        {
            auto OpenScreenshotFolder = [HyperLinkString]
            {
                FPlatformProcess::ExploreFolder(*FPaths::GetPath(HyperLinkString));
            };

            SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotSavedAs", "Screenshot capture saved as"));

            SaveMessagePtr->SetHyperlink(FSimpleDelegate::CreateLambda(OpenScreenshotFolder), FText::FromString(HyperLinkString));
            SaveMessagePtr->SetCompletionState(SNotificationItem::CS_Success);
        }
        else
        {
            SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotFailed_CouldNotSave", "Screenshot failed, unable to save"));
            SaveMessagePtr->SetCompletionState(SNotificationItem::CS_Fail);
        }
    };

    TFuture<bool> CompletionFuture = HighResScreenshotConfig.ImageWriteQueue->Enqueue(MoveTemp(ImageTask));
    if (CompletionFuture.IsValid())
    {
        SaveMessagePtr->SetCompletionState(SNotificationItem::CS_Pending);
    }
    else
    {
        // Unable to write the data for an unknown reason
        SaveMessagePtr->SetText(NSLOCTEXT("UnrealEd", "ScreenshotFailedWrite", "Screenshot failed, corrupt data captured from the viewport."));
    }
}

/**
 * Implements screenshot capture for editor viewports.
 */
bool FEditorViewportClient::InputTakeScreenshot(FViewport* InViewport, FKey Key, EInputEvent Event)
{
    const bool F9Down = InViewport->KeyState(EKeys::F9);

    // Whether or not we accept the key press
    bool bHandled = false;

    if (F9Down)
    {
        if (Key == EKeys::LeftMouseButton)
        {
            if (Event == IE_Pressed)
            {
                // We need to invalidate the viewport in order to generate the correct pixel buffer for picking.
                Invalidate(false, true);
            }
            else if (Event == IE_Released)
            {
                TakeScreenshot(InViewport, false);
            }
            bHandled = true;
        }
    }

    return bHandled;
}

void FEditorViewportClient::TakeHighResScreenShot()
{
    if (Viewport)
    {
        Viewport->TakeHighResScreenShot();
    }
}

bool FEditorViewportClient::ProcessScreenShots(FViewport* InViewport)
{
    bool bIsScreenshotSaved = false;

    if (GIsDumpingMovie || FScreenshotRequest::IsScreenshotRequested() || GIsHighResScreenshot)
    {
        // Default capture region is the entire viewport
        FIntRect CaptureRect(0, 0, 0, 0);

        FHighResScreenshotConfig& HighResScreenshotConfig = GetHighResScreenshotConfig();
        bool bCaptureAreaValid                            = HighResScreenshotConfig.CaptureRegion.Area() > 0;

        if (!ensure(HighResScreenshotConfig.ImageWriteQueue))
        {
            return false;
        }

        // If capture region isn't valid, we need to determine which rectangle to capture from.
        // We need to calculate a proper view rectangle so that we can take into account camera
        // properties, such as it being aspect ratio constrained
        if (GIsHighResScreenshot && !bCaptureAreaValid)
        {
            // Screen Percentage is an optimization and should not affect the editor by default, unless we're rendering in stereo
            bool bUseScreenPercentage = GEngine && GEngine->IsStereoscopic3D(InViewport);

            FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
                                                   InViewport,
                                                   GetScene(),
                                                   EngineShowFlags)
                                                   .SetRealtimeUpdate(IsRealtime())
                                                   .SetViewModeParam(ViewModeParam, ViewModeParamName));

            ViewFamily.EngineShowFlags.SetScreenPercentage(bUseScreenPercentage);

            auto* ViewportBak = Viewport;
            Viewport          = InViewport;
            FSceneView* View  = CalcSceneView(&ViewFamily);
            Viewport          = ViewportBak;
            CaptureRect       = View->UnscaledViewRect;
        }

        TArray<FColor> Bitmap;
        if (GetViewportScreenShot(InViewport, Bitmap, CaptureRect))
        {
            // Determine the size of the captured viewport data.
            FIntPoint BitmapSize = CaptureRect.Area() > 0 ? CaptureRect.Size() : InViewport->GetSizeXY();

            // Determine which region of the captured data we want to save out. If the highres screenshot capture region
            // is not valid, we want to save out everything in the viewrect that we just grabbed.
            FIntRect SourceRect = FIntRect(0, 0, 0, 0);
            if (GIsHighResScreenshot && bCaptureAreaValid)
            {
                // Highres screenshot capture region is valid, so use that
                SourceRect = HighResScreenshotConfig.CaptureRegion;
            }

            bool bWriteAlpha = false;

            // If this is a high resolution screenshot and we are using the masking feature,
            // Get the results of the mask rendering pass and insert into the alpha channel of the screenshot.
            if (GIsHighResScreenshot && HighResScreenshotConfig.bMaskEnabled)
            {
                bWriteAlpha = HighResScreenshotConfig.MergeMaskIntoAlpha(Bitmap);
            }

            // Clip the bitmap to just the capture region if valid
            if (!SourceRect.IsEmpty())
            {
                FColor* const Data            = Bitmap.GetData();
                const int32 OldWidth          = BitmapSize.X;
                const int32 OldHeight         = BitmapSize.Y;
                const int32 NewWidth          = SourceRect.Width();
                const int32 NewHeight         = SourceRect.Height();
                const int32 CaptureTopRow     = SourceRect.Min.Y;
                const int32 CaptureLeftColumn = SourceRect.Min.X;

                for (int32 Row = 0; Row < NewHeight; Row++)
                {
                    FMemory::Memmove(Data + Row * NewWidth, Data + (Row + CaptureTopRow) * OldWidth + CaptureLeftColumn, NewWidth * sizeof(*Data));
                }

                Bitmap.RemoveAt(NewWidth * NewHeight, OldWidth * OldHeight - NewWidth * NewHeight, false);
                BitmapSize = FIntPoint(NewWidth, NewHeight);
            }

            if (GIsAutomationTesting)
            {
                // Under automation test, the screenshot is highjacked and sent to be compared
                TArray<FColor> BitmapForCompare(Bitmap);
                if (!bWriteAlpha)
                {
                    // Set full alpha on the bitmap
                    for (FColor& Pixel: BitmapForCompare)
                    {
                        Pixel.A = 255;
                    }
                }

                FScreenshotRequest::OnScreenshotCaptured().Broadcast(BitmapSize.X, BitmapSize.Y, MoveTemp(BitmapForCompare));
            }

            TUniquePtr<FImageWriteTask> ImageTask = MakeUnique<FImageWriteTask>();
            ImageTask->PixelData                  = MakeUnique<TImagePixelData<FColor>>(BitmapSize, TArray64<FColor>(MoveTemp(Bitmap)));

            // Set full alpha on the bitmap
            if (!bWriteAlpha)
            {
                ImageTask->PixelPreProcessors.Add(TAsyncAlphaWrite<FColor>(255));
            }

            HighResScreenshotConfig.PopulateImageTaskParams(*ImageTask);
            ImageTask->Filename = FScreenshotRequest::GetFilename();

            // Save the bitmap to disc
            TFuture<bool> CompletionFuture = HighResScreenshotConfig.ImageWriteQueue->Enqueue(MoveTemp(ImageTask));
            if (CompletionFuture.IsValid())
            {
                bIsScreenshotSaved = CompletionFuture.Get();
            }
        }

        // Done with the request
        FScreenshotRequest::Reset();
        FScreenshotRequest::OnScreenshotRequestProcessed().Broadcast();

        // Re-enable screen messages - if we are NOT capturing a movie
        GAreScreenMessagesEnabled = GScreenMessagesRestoreState;

        InViewport->InvalidateHitProxy();
    }

    return bIsScreenshotSaved;
}

void FEditorViewportClient::DrawBoundingBox(FBox& Box, FCanvas* InCanvas, const FSceneView* InView, const FViewport* InViewport, const FLinearColor& InColor, const bool bInDrawBracket, const FString& InLabelText)
{
    FVector BoxCenter, BoxExtents;
    Box.GetCenterAndExtents(BoxCenter, BoxExtents);

    // Project center of bounding box onto screen.
    const FVector4 ProjBoxCenter = InView->WorldToScreen(BoxCenter);

    // Do nothing if behind camera
    if (ProjBoxCenter.W > 0.f)
    {
        // Project verts of world-space bounding box onto screen and take their bounding box
        const FVector Verts[8] = {FVector(1, 1, 1),
                                  FVector(1, 1, -1),
                                  FVector(1, -1, 1),
                                  FVector(1, -1, -1),
                                  FVector(-1, 1, 1),
                                  FVector(-1, 1, -1),
                                  FVector(-1, -1, 1),
                                  FVector(-1, -1, -1)};

        const int32 HalfX      = 0.5f * InViewport->GetSizeXY().X;
        const int32 HalfY      = 0.5f * InViewport->GetSizeXY().Y;

        FVector2D ScreenBoxMin(1000000000, 1000000000);
        FVector2D ScreenBoxMax(-1000000000, -1000000000);

        for (int32 j = 0; j < 8; j++)
        {
            // Project vert into screen space.
            const FVector WorldVert = BoxCenter + (Verts[j] * BoxExtents);
            FVector2D PixelVert;
            if (InView->ScreenToPixel(InView->WorldToScreen(WorldVert), PixelVert))
            {
                // Update screen-space bounding box with with transformed vert.
                ScreenBoxMin.X = FMath::Min<int32>(ScreenBoxMin.X, PixelVert.X);
                ScreenBoxMin.Y = FMath::Min<int32>(ScreenBoxMin.Y, PixelVert.Y);

                ScreenBoxMax.X = FMath::Max<int32>(ScreenBoxMax.X, PixelVert.X);
                ScreenBoxMax.Y = FMath::Max<int32>(ScreenBoxMax.Y, PixelVert.Y);
            }
        }

        FCanvasLineItem LineItem(FVector2D(0.0f, 0.0f), FVector2D(0.0f, 0.0f));
        LineItem.SetColor(InColor);
        if (bInDrawBracket)
        {
            // Draw a bracket when considering the non-current level.
            const float DeltaX = ScreenBoxMax.X - ScreenBoxMin.X;
            const float DeltaY = ScreenBoxMax.X - ScreenBoxMin.X;
            const FIntPoint Offset(DeltaX * 0.2f, DeltaY * 0.2f);

            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMin.X + Offset.X, ScreenBoxMin.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMin.X + Offset.X, ScreenBoxMax.Y));

            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMax.X - Offset.X, ScreenBoxMin.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMax.X - Offset.X, ScreenBoxMax.Y));

            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMin.X, ScreenBoxMin.Y + Offset.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMax.X, ScreenBoxMin.Y + Offset.Y));

            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMin.X, ScreenBoxMax.Y - Offset.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMax.X, ScreenBoxMax.Y - Offset.Y));
        }
        else
        {
            // Draw a box when considering the current level.
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMin.X, ScreenBoxMax.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMin.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMax.X, ScreenBoxMax.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMax.Y), FVector2D(ScreenBoxMax.X, ScreenBoxMin.Y));
            LineItem.Draw(InCanvas, FVector2D(ScreenBoxMax.X, ScreenBoxMin.Y), FVector2D(ScreenBoxMin.X, ScreenBoxMin.Y));
        }

        if (InLabelText.Len() > 0)
        {
            FCanvasTextItem TextItem(FVector2D(ScreenBoxMin.X + ((ScreenBoxMax.X - ScreenBoxMin.X) * 0.5f), ScreenBoxMin.Y), FText::FromString(InLabelText), GEngine->GetMediumFont(), InColor);
            TextItem.bCentreX = true;
            InCanvas->DrawItem(TextItem);
        }
    }
}

void FEditorViewportClient::DrawActorScreenSpaceBoundingBox(FCanvas* InCanvas, const FSceneView* InView, FViewport* InViewport, AActor* InActor, const FLinearColor& InColor, const bool bInDrawBracket, const FString& InLabelText)
{
    check(InActor != NULL);

    // First check to see if we're dealing with a sprite, otherwise just use the normal bounding box
    UBillboardComponent* Sprite = InActor->FindComponentByClass<UBillboardComponent>();

    FBox ActorBox;
    if (Sprite != NULL)
    {
        ActorBox = Sprite->Bounds.GetBox();
    }
    else
    {
        const bool bNonColliding = true;
        ActorBox                 = InActor->GetComponentsBoundingBox(bNonColliding);
    }

    // If we didn't get a valid bounding box, just make a little one around the actor location
    if (!ActorBox.IsValid || ActorBox.GetExtent().GetMin() < KINDA_SMALL_NUMBER)
    {
        ActorBox = FBox(InActor->GetActorLocation() - FVector(-20), InActor->GetActorLocation() + FVector(20));
    }

    DrawBoundingBox(ActorBox, InCanvas, InView, InViewport, InColor, bInDrawBracket, InLabelText);
}

void FEditorViewportClient::SetGameView(bool bGameViewEnable)
{
    // backup this state as we want to preserve it
    bool bCompositeEditorPrimitives = EngineShowFlags.CompositeEditorPrimitives;

    // defaults
    FEngineShowFlags GameFlags(ESFIM_Game);
    FEngineShowFlags EditorFlags(ESFIM_Editor);
    {
        // likely we can take the existing state
        if (EngineShowFlags.Game)
        {
            GameFlags   = EngineShowFlags;
            EditorFlags = LastEngineShowFlags;
        }
        else if (LastEngineShowFlags.Game)
        {
            GameFlags   = LastEngineShowFlags;
            EditorFlags = EngineShowFlags;
        }
    }

    // toggle between the game and engine flags
    if (bGameViewEnable)
    {
        EngineShowFlags     = GameFlags;
        LastEngineShowFlags = EditorFlags;
    }
    else
    {
        EngineShowFlags     = EditorFlags;
        LastEngineShowFlags = GameFlags;
    }

    // maintain this state
    EngineShowFlags.SetCompositeEditorPrimitives(bCompositeEditorPrimitives);
    LastEngineShowFlags.SetCompositeEditorPrimitives(bCompositeEditorPrimitives);

    // reset game engine show flags that may have been turned on by making a selection in game view
    if (bGameViewEnable)
    {
        EngineShowFlags.SetModeWidgets(false);
        EngineShowFlags.SetSelection(false);
    }

    EngineShowFlags.SetSelectionOutline(bGameViewEnable ? false : GetDefault<ULevelEditorViewportSettings>()->bUseSelectionOutline);

    ApplyViewMode(GetViewMode(), IsPerspective(), EngineShowFlags);

    bInGameViewMode = bGameViewEnable;

    Invalidate();
}

void FEditorViewportClient::SetVREditView(bool bVREditViewEnable)
{
    // backup this state as we want to preserve it
    bool bCompositeEditorPrimitives = EngineShowFlags.CompositeEditorPrimitives;

    // defaults
    FEngineShowFlags VREditFlags(ESFIM_VREditing);
    FEngineShowFlags EditorFlags(ESFIM_Editor);
    {
        // likely we can take the existing state
        if (EngineShowFlags.VREditing)
        {
            VREditFlags = EngineShowFlags;
            EditorFlags = LastEngineShowFlags;
        }
        else if (LastEngineShowFlags.VREditing)
        {
            VREditFlags = LastEngineShowFlags;
            EditorFlags = EngineShowFlags;
        }
    }

    // toggle between the game and engine flags
    if (bVREditViewEnable)
    {
        EngineShowFlags     = VREditFlags;
        LastEngineShowFlags = EditorFlags;
    }
    else
    {
        EngineShowFlags     = EditorFlags;
        LastEngineShowFlags = VREditFlags;
    }
    // maintain this state
    EngineShowFlags.SetCompositeEditorPrimitives(bCompositeEditorPrimitives);
    LastEngineShowFlags.SetCompositeEditorPrimitives(bCompositeEditorPrimitives);

    // reset game engine show flags that may have been turned on by making a selection in game view
    if (bVREditViewEnable)
    {
        EngineShowFlags.SetModeWidgets(false);
        EngineShowFlags.SetBillboardSprites(false);
    }

    EngineShowFlags.SetSelectionOutline(bVREditViewEnable ? true : GetDefault<ULevelEditorViewportSettings>()->bUseSelectionOutline);

    ApplyViewMode(GetViewMode(), IsPerspective(), EngineShowFlags);

    bInVREditViewMode = bVREditViewEnable;

    Invalidate();
}

FStatUnitData* FEditorViewportClient::GetStatUnitData() const
{
    return &StatUnitData;
}

FStatHitchesData* FEditorViewportClient::GetStatHitchesData() const
{
    return &StatHitchesData;
}

const TArray<FString>* FEditorViewportClient::GetEnabledStats() const
{
    return &EnabledStats;
}

void FEditorViewportClient::SetEnabledStats(const TArray<FString>& InEnabledStats)
{
    HandleViewportStatDisableAll(true);

    EnabledStats = InEnabledStats;
    if (EnabledStats.Num())
    {
        SetShowStats(true);
        AddRealtimeOverride(true, LOCTEXT("RealtimeOverrideMessage_Stats", "Stats Display"));
    }

#if ENABLE_AUDIO_DEBUG
    if (GEngine)
    {
        if (FAudioDeviceManager* DeviceManager = GEngine->GetAudioDeviceManager())
        {
            Audio::FAudioDebugger::ResolveDesiredStats(this);
        }
    }
#endif  // ENABLE_AUDIO_DEBUG
}

bool FEditorViewportClient::IsStatEnabled(const FString& InName) const
{
    return EnabledStats.Contains(InName);
}

float FEditorViewportClient::UpdateViewportClientWindowDPIScale() const
{
    float DPIScale = 1.f;
    if (EditorViewportWidget.IsValid())
    {
        TSharedPtr<SWindow> WidgetWindow = FSlateApplication::Get().FindWidgetWindow(EditorViewportWidget.Pin().ToSharedRef());
        if (WidgetWindow.IsValid())
        {
            DPIScale = WidgetWindow->GetNativeWindow()->GetDPIScaleFactor();
        }
    }

    return DPIScale;
}

FMatrix FEditorViewportClient::CalcViewRotationMatrix(const FRotator& InViewRotation) const
{
    const FViewportCameraTransform& ViewTransform = GetViewTransform();

    if (bUsingOrbitCamera)
    {
        // @todo vreditor: Not stereo friendly yet
        return FTranslationMatrix(ViewTransform.GetLocation()) * ViewTransform.ComputeOrbitMatrix();
    }
    else
    {
        // Create the view matrix
        return FInverseRotationMatrix(InViewRotation);
    }
}

void FEditorViewportClient::EnableOverrideEngineShowFlags(TUniqueFunction<void(FEngineShowFlags&)> OverrideFunc)
{
    OverrideShowFlagsFunc = MoveTemp(OverrideFunc);
}

void FEditorViewportClient::DisableOverrideEngineShowFlags()
{
    OverrideShowFlagsFunc = nullptr;
}

float FEditorViewportClient::GetMinimumOrthoZoom() const
{
    return FMath::Max(GetDefault<ULevelEditorViewportSettings>()->MinimumOrthographicZoom, 1.0f);
}

////////////////

bool FEditorViewportStats::bInitialized(false);
bool FEditorViewportStats::bUsingCalledThisFrame(false);
FEditorViewportStats::Category FEditorViewportStats::LastUsing(FEditorViewportStats::CAT_MAX);
int32 FEditorViewportStats::DataPoints[FEditorViewportStats::CAT_MAX];

void FEditorViewportStats::Initialize()
{
    if (!bInitialized)
    {
        bInitialized = true;
        FMemory::Memzero(DataPoints);
    }
}

void FEditorViewportStats::Used(FEditorViewportStats::Category InCategory)
{
    Initialize();
    DataPoints[InCategory] += 1;
}

void FEditorViewportStats::BeginFrame()
{
    Initialize();
    bUsingCalledThisFrame = false;
}

void FEditorViewportStats::Using(Category InCategory)
{
    Initialize();

    bUsingCalledThisFrame = true;

    if (LastUsing != InCategory)
    {
        LastUsing = InCategory;
        DataPoints[InCategory] += 1;
    }
}

void FEditorViewportStats::NoOpUsing()
{
    Initialize();

    bUsingCalledThisFrame = true;
}

void FEditorViewportStats::EndFrame()
{
    Initialize();

    if (!bUsingCalledThisFrame)
    {
        LastUsing = FEditorViewportStats::CAT_MAX;
    }
}

void FEditorViewportStats::SendUsageData()
{
    Initialize();

    static_assert(FEditorViewportStats::CAT_MAX == 22, "If the number of categories change you need to add more entries below!");

    TArray<FAnalyticsEventAttribute> PerspectiveUsage;
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.WASD"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_WASD]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.UpDown"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_UP_DOWN]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.FovZoom"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_KEYBOARD_FOV_ZOOM]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Dolly"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_DOLLY]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Pan"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_PAN]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Scroll"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_SCROLL]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Rotation"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_ROTATION]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Pan"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_PAN]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Zoom"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_MOUSE_ORBIT_ZOOM]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Gesture.Scroll"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_GESTURE_SCROLL]));
    PerspectiveUsage.Add(FAnalyticsEventAttribute(FString("Gesture.Magnify"), DataPoints[FEditorViewportStats::CAT_PERSPECTIVE_GESTURE_MAGNIFY]));

    TArray<FAnalyticsEventAttribute> OrthographicUsage;
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.WASD"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_KEYBOARD_WASD]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.UpDown"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_KEYBOARD_UP_DOWN]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Keyboard.FovZoom"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_KEYBOARD_FOV_ZOOM]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Zoom"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ZOOM]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Pan"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_PAN]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Scroll"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_SCROLL]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Rotation"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_ROTATION]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Pan"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_PAN]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Mouse.Orbit.Zoom"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_MOUSE_ORBIT_ZOOM]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Gesture.Scroll"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_GESTURE_SCROLL]));
    OrthographicUsage.Add(FAnalyticsEventAttribute(FString("Gesture.Magnify"), DataPoints[FEditorViewportStats::CAT_ORTHOGRAPHIC_GESTURE_MAGNIFY]));

    FEngineAnalytics::GetProvider().RecordEvent(FString("Editor.Usage.Viewport.Perspective"), PerspectiveUsage);
    FEngineAnalytics::GetProvider().RecordEvent(FString("Editor.Usage.Viewport.Orthographic"), OrthographicUsage);

    // Clear all the usage data in case we do it twice.
    FMemory::Memzero(DataPoints);
}

FViewportNavigationCommands::FViewportNavigationCommands()
    : TCommands<FViewportNavigationCommands>(
          "EditorViewportClient",                                              // Context name for fast lookup
          NSLOCTEXT("Contexts", "ViewportNavigation", "Viewport Navigation"),  // Localized context name for displaying
          FName(),
          FEditorStyle::GetStyleSetName()  // Icon Style Set
      )
{
}

void FViewportNavigationCommands::RegisterCommands()
{
    UI_COMMAND(Forward, "Forward", "Moves the camera Forward", EUserInterfaceActionType::Button, FInputChord(EKeys::W));
    UI_COMMAND(Backward, "Backward", "Moves the camera Backward", EUserInterfaceActionType::Button, FInputChord(EKeys::S));
    UI_COMMAND(Left, "Left", "Moves the camera Left", EUserInterfaceActionType::Button, FInputChord(EKeys::A));
    UI_COMMAND(Right, "Right", "Moves the camera Right", EUserInterfaceActionType::Button, FInputChord(EKeys::D));

    UI_COMMAND(Up, "Up", "Moves the camera Up", EUserInterfaceActionType::Button, FInputChord(EKeys::E));
    UI_COMMAND(Down, "Down", "Moves the camera Down", EUserInterfaceActionType::Button, FInputChord(EKeys::Q));

    UI_COMMAND(FovZoomIn, "FOV Zoom In", "Narrows the camers FOV", EUserInterfaceActionType::Button, FInputChord(EKeys::C));
    UI_COMMAND(FovZoomOut, "FOV Zoom Out", "Widens the camera FOV", EUserInterfaceActionType::Button, FInputChord(EKeys::Z));
}

#undef LOCTEXT_NAMESPACE