Merge pull request #1422 from aws-lumberyard-dev/nvsickle/CameraInputHardening

Switch RenderViewportWidget to Qt based events instead of AzFramework ones
2021-07-08 11:23:31 -05:00
parent 1a2f83043d c8fb453760
commit 15acb6b85a
13 changed files with 619 additions and 103 deletions
@@ -714,7 +714,7 @@ void EditorViewportWidget::OnEditorNotifyEvent(EEditorNotifyEvent event)

        if (m_renderViewport)
        {
-            m_renderViewport->GetControllerList()->SetEnabled(false);
+            m_renderViewport->SetInputProcessingEnabled(false);
        }
    }
    break;
@@ -738,7 +738,7 @@ void EditorViewportWidget::OnEditorNotifyEvent(EEditorNotifyEvent event)

        if (m_renderViewport)
        {
-            m_renderViewport->GetControllerList()->SetEnabled(true);
+            m_renderViewport->SetInputProcessingEnabled(true);
        }
        break;

@@ -404,7 +404,7 @@ bool LegacyViewportCameraControllerInstance::HandleInputChannelEvent(const AzFra
    }
    else if (auto key = GetKeyboardKey(event.m_inputChannel); key != Qt::Key_unknown)
    {
-        if (state == InputChannel::State::Ended)
+        if (!event.m_inputChannel.IsActive())
        {
            m_pressedKeys.erase(key);
        }
@@ -216,7 +216,8 @@ namespace SandboxEditor
                interactionHandled, AzToolsFramework::GetEntityContextId(), targetInteractionEvent, mouseInteractionEvent);
        }

-        return interactionHandled;
+        // Only filter button/key press events, not release events
+        return interactionHandled && event.m_inputChannel.IsActive();
    }

    void ViewportManipulatorControllerInstance::ResetInputChannels()
@@ -454,8 +454,8 @@ namespace AzFramework
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////
-    InputDeviceKeyboard::InputDeviceKeyboard()
-        : InputDevice(Id)
+    InputDeviceKeyboard::InputDeviceKeyboard(AzFramework::InputDeviceId id)
+        : InputDevice(id)
        , m_modifierKeyStates(AZStd::make_shared<ModifierKeyStates>())
        , m_allChannelsById()
        , m_keyChannelsById()
@@ -240,7 +240,7 @@ namespace AzFramework

        ////////////////////////////////////////////////////////////////////////////////////////////
        //! Constructor
-        InputDeviceKeyboard();
+        InputDeviceKeyboard(AzFramework::InputDeviceId id = Id);

        ////////////////////////////////////////////////////////////////////////////////////////////
        // Disable copying
@@ -95,8 +95,8 @@ namespace AzFramework
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////
-    InputDeviceMouse::InputDeviceMouse()
-        : InputDevice(Id)
+    InputDeviceMouse::InputDeviceMouse(AzFramework::InputDeviceId id)
+        : InputDevice(id)
        , m_allChannelsById()
        , m_buttonChannelsById()
        , m_movementChannelsById()
@@ -111,7 +111,7 @@ namespace AzFramework

        ////////////////////////////////////////////////////////////////////////////////////////////
        //! Constructor
-        explicit InputDeviceMouse();
+        explicit InputDeviceMouse(AzFramework::InputDeviceId id = Id);

        ////////////////////////////////////////////////////////////////////////////////////////////
        // Disable copying
@@ -747,19 +747,24 @@ namespace AzFramework
                return button == inputChannelId;
            });

-        if (inputChannelId == InputDeviceMouse::Movement::X)
+        // accept active mouse channel updates, inactive movement channels will just have a 0 delta
+        if (inputChannel.IsActive())
        {
-            return HorizontalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
+            if (inputChannelId == InputDeviceMouse::Movement::X)
+            {
+                return HorizontalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
+            }
+            else if (inputChannelId == InputDeviceMouse::Movement::Y)
+            {
+                return VerticalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
+            }
+            else if (inputChannelId == InputDeviceMouse::Movement::Z)
+            {
+                return ScrollEvent{ inputChannel.GetValue() };
+            }
        }
-        else if (inputChannelId == InputDeviceMouse::Movement::Y)
-        {
-            return VerticalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
-        }
-        else if (inputChannelId == InputDeviceMouse::Movement::Z)
-        {
-            return ScrollEvent{ inputChannel.GetValue() };
-        }
-        else if (wasMouseButton || InputDeviceKeyboard::IsKeyboardDevice(inputDeviceId))
+
+        if (wasMouseButton || InputDeviceKeyboard::IsKeyboardDevice(inputDeviceId))
        {
            return DiscreteInputEvent{ inputChannelId, inputChannel.GetState() };
        }
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ * 
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Input/QtEventToAzInputManager.h>
+
+#include <AzCore/std/smart_ptr/make_shared.h>
+
+#include <AzFramework/Input/Buses/Notifications/InputChannelNotificationBus.h>
+#include <AzFramework/Input/Buses/Requests/InputChannelRequestBus.h>
+
+#include <QApplication>
+#include <QCursor>
+#include <QEvent>
+#include <QKeyEvent>
+#include <QMouseEvent>
+#include <QWheelEvent>
+#include <QWidget>
+
+namespace AzToolsFramework
+{
+    void QtEventToAzInputMapper::InitializeKeyMappings()
+    {
+        // This assumes modifier keys (ctrl/shift/alt) map to the left control/shift/alt keys as Qt provides no way to disambiguate
+        // in a platform agnostic manner. This could be expanded later with a PAL mapping from native scan codes acquired from
+        // QKeyEvents, if needed.
+        m_keyMappings = { {
+            { Qt::Key_0, AzFramework::InputDeviceKeyboard::Key::Alphanumeric0 },
+            { Qt::Key_1, AzFramework::InputDeviceKeyboard::Key::Alphanumeric1 },
+            { Qt::Key_2, AzFramework::InputDeviceKeyboard::Key::Alphanumeric2 },
+            { Qt::Key_3, AzFramework::InputDeviceKeyboard::Key::Alphanumeric3 },
+            { Qt::Key_4, AzFramework::InputDeviceKeyboard::Key::Alphanumeric4 },
+            { Qt::Key_5, AzFramework::InputDeviceKeyboard::Key::Alphanumeric5 },
+            { Qt::Key_6, AzFramework::InputDeviceKeyboard::Key::Alphanumeric6 },
+            { Qt::Key_7, AzFramework::InputDeviceKeyboard::Key::Alphanumeric7 },
+            { Qt::Key_8, AzFramework::InputDeviceKeyboard::Key::Alphanumeric8 },
+            { Qt::Key_9, AzFramework::InputDeviceKeyboard::Key::Alphanumeric9 },
+            { Qt::Key_A, AzFramework::InputDeviceKeyboard::Key::AlphanumericA },
+            { Qt::Key_B, AzFramework::InputDeviceKeyboard::Key::AlphanumericB },
+            { Qt::Key_C, AzFramework::InputDeviceKeyboard::Key::AlphanumericC },
+            { Qt::Key_D, AzFramework::InputDeviceKeyboard::Key::AlphanumericD },
+            { Qt::Key_E, AzFramework::InputDeviceKeyboard::Key::AlphanumericE },
+            { Qt::Key_F, AzFramework::InputDeviceKeyboard::Key::AlphanumericF },
+            { Qt::Key_G, AzFramework::InputDeviceKeyboard::Key::AlphanumericG },
+            { Qt::Key_H, AzFramework::InputDeviceKeyboard::Key::AlphanumericH },
+            { Qt::Key_I, AzFramework::InputDeviceKeyboard::Key::AlphanumericI },
+            { Qt::Key_J, AzFramework::InputDeviceKeyboard::Key::AlphanumericJ },
+            { Qt::Key_K, AzFramework::InputDeviceKeyboard::Key::AlphanumericK },
+            { Qt::Key_L, AzFramework::InputDeviceKeyboard::Key::AlphanumericL },
+            { Qt::Key_M, AzFramework::InputDeviceKeyboard::Key::AlphanumericM },
+            { Qt::Key_N, AzFramework::InputDeviceKeyboard::Key::AlphanumericN },
+            { Qt::Key_O, AzFramework::InputDeviceKeyboard::Key::AlphanumericO },
+            { Qt::Key_P, AzFramework::InputDeviceKeyboard::Key::AlphanumericP },
+            { Qt::Key_Q, AzFramework::InputDeviceKeyboard::Key::AlphanumericQ },
+            { Qt::Key_R, AzFramework::InputDeviceKeyboard::Key::AlphanumericR },
+            { Qt::Key_S, AzFramework::InputDeviceKeyboard::Key::AlphanumericS },
+            { Qt::Key_T, AzFramework::InputDeviceKeyboard::Key::AlphanumericT },
+            { Qt::Key_U, AzFramework::InputDeviceKeyboard::Key::AlphanumericU },
+            { Qt::Key_V, AzFramework::InputDeviceKeyboard::Key::AlphanumericV },
+            { Qt::Key_W, AzFramework::InputDeviceKeyboard::Key::AlphanumericW },
+            { Qt::Key_X, AzFramework::InputDeviceKeyboard::Key::AlphanumericX },
+            { Qt::Key_Y, AzFramework::InputDeviceKeyboard::Key::AlphanumericY },
+            { Qt::Key_Z, AzFramework::InputDeviceKeyboard::Key::AlphanumericZ },
+            { Qt::Key_Backspace, AzFramework::InputDeviceKeyboard::Key::EditBackspace },
+            { Qt::Key_CapsLock, AzFramework::InputDeviceKeyboard::Key::EditCapsLock },
+            { Qt::Key_Enter, AzFramework::InputDeviceKeyboard::Key::EditEnter },
+            { Qt::Key_Space, AzFramework::InputDeviceKeyboard::Key::EditSpace },
+            { Qt::Key_Tab, AzFramework::InputDeviceKeyboard::Key::EditTab },
+            { Qt::Key_Escape, AzFramework::InputDeviceKeyboard::Key::Escape },
+            { Qt::Key_F1, AzFramework::InputDeviceKeyboard::Key::Function01 },
+            { Qt::Key_F2, AzFramework::InputDeviceKeyboard::Key::Function02 },
+            { Qt::Key_F3, AzFramework::InputDeviceKeyboard::Key::Function03 },
+            { Qt::Key_F4, AzFramework::InputDeviceKeyboard::Key::Function04 },
+            { Qt::Key_F5, AzFramework::InputDeviceKeyboard::Key::Function05 },
+            { Qt::Key_F6, AzFramework::InputDeviceKeyboard::Key::Function06 },
+            { Qt::Key_F7, AzFramework::InputDeviceKeyboard::Key::Function07 },
+            { Qt::Key_F8, AzFramework::InputDeviceKeyboard::Key::Function08 },
+            { Qt::Key_F9, AzFramework::InputDeviceKeyboard::Key::Function09 },
+            { Qt::Key_F10, AzFramework::InputDeviceKeyboard::Key::Function10 },
+            { Qt::Key_F11, AzFramework::InputDeviceKeyboard::Key::Function11 },
+            { Qt::Key_F12, AzFramework::InputDeviceKeyboard::Key::Function12 },
+            { Qt::Key_F13, AzFramework::InputDeviceKeyboard::Key::Function13 },
+            { Qt::Key_F14, AzFramework::InputDeviceKeyboard::Key::Function14 },
+            { Qt::Key_F15, AzFramework::InputDeviceKeyboard::Key::Function15 },
+            { Qt::Key_F16, AzFramework::InputDeviceKeyboard::Key::Function16 },
+            { Qt::Key_F17, AzFramework::InputDeviceKeyboard::Key::Function17 },
+            { Qt::Key_F18, AzFramework::InputDeviceKeyboard::Key::Function18 },
+            { Qt::Key_F19, AzFramework::InputDeviceKeyboard::Key::Function19 },
+            { Qt::Key_F20, AzFramework::InputDeviceKeyboard::Key::Function20 },
+            { Qt::Key_Alt, AzFramework::InputDeviceKeyboard::Key::ModifierAltL },
+            { Qt::Key_Control, AzFramework::InputDeviceKeyboard::Key::ModifierCtrlL },
+            { Qt::Key_Shift, AzFramework::InputDeviceKeyboard::Key::ModifierShiftL },
+            { Qt::Key_Super_L, AzFramework::InputDeviceKeyboard::Key::ModifierSuperL },
+            { Qt::Key_Super_R, AzFramework::InputDeviceKeyboard::Key::ModifierSuperR },
+            { Qt::Key_Down, AzFramework::InputDeviceKeyboard::Key::NavigationArrowDown },
+            { Qt::Key_Left, AzFramework::InputDeviceKeyboard::Key::NavigationArrowLeft },
+            { Qt::Key_Right, AzFramework::InputDeviceKeyboard::Key::NavigationArrowRight },
+            { Qt::Key_Up, AzFramework::InputDeviceKeyboard::Key::NavigationArrowUp },
+            { Qt::Key_Delete, AzFramework::InputDeviceKeyboard::Key::NavigationDelete },
+            { Qt::Key_End, AzFramework::InputDeviceKeyboard::Key::NavigationEnd },
+            { Qt::Key_Home, AzFramework::InputDeviceKeyboard::Key::NavigationHome },
+            { Qt::Key_Insert, AzFramework::InputDeviceKeyboard::Key::NavigationInsert },
+            { Qt::Key_PageDown, AzFramework::InputDeviceKeyboard::Key::NavigationPageDown },
+            { Qt::Key_PageUp, AzFramework::InputDeviceKeyboard::Key::NavigationPageUp },
+            { Qt::Key_Apostrophe, AzFramework::InputDeviceKeyboard::Key::PunctuationApostrophe },
+            { Qt::Key_Backslash, AzFramework::InputDeviceKeyboard::Key::PunctuationBackslash },
+            { Qt::Key_BracketLeft, AzFramework::InputDeviceKeyboard::Key::PunctuationBracketL },
+            { Qt::Key_BracketRight, AzFramework::InputDeviceKeyboard::Key::PunctuationBracketR },
+            { Qt::Key_Comma, AzFramework::InputDeviceKeyboard::Key::PunctuationComma },
+            { Qt::Key_Equal, AzFramework::InputDeviceKeyboard::Key::PunctuationEquals },
+            { Qt::Key_hyphen, AzFramework::InputDeviceKeyboard::Key::PunctuationHyphen },
+            { Qt::Key_Period, AzFramework::InputDeviceKeyboard::Key::PunctuationPeriod },
+            { Qt::Key_Semicolon, AzFramework::InputDeviceKeyboard::Key::PunctuationSemicolon },
+            { Qt::Key_Slash, AzFramework::InputDeviceKeyboard::Key::PunctuationSlash },
+            { Qt::Key_QuoteLeft, AzFramework::InputDeviceKeyboard::Key::PunctuationTilde },
+            { Qt::Key_Pause, AzFramework::InputDeviceKeyboard::Key::WindowsSystemPause },
+            { Qt::Key_Print, AzFramework::InputDeviceKeyboard::Key::WindowsSystemPrint },
+            { Qt::Key_ScrollLock, AzFramework::InputDeviceKeyboard::Key::WindowsSystemScrollLock },
+        } };
+    }
+
+    void QtEventToAzInputMapper::InitializeMouseButtonMappings()
+    {
+        m_mouseButtonMappings = { {
+            { Qt::MouseButton::LeftButton, AzFramework::InputDeviceMouse::Button::Left },
+            { Qt::MouseButton::RightButton, AzFramework::InputDeviceMouse::Button::Right },
+            { Qt::MouseButton::MiddleButton, AzFramework::InputDeviceMouse::Button::Middle },
+            { Qt::MouseButton::ExtraButton1, AzFramework::InputDeviceMouse::Button::Other1 },
+            { Qt::MouseButton::ExtraButton2, AzFramework::InputDeviceMouse::Button::Other2 },
+        } };
+    }
+
+    // Currently this is only set for modifier keys.
+    // This should only be expanded sparingly, any keys handled here will not be bubbled up to the shortcut system.
+    // ex: If Key_S was here, the viewport would consume S key presses before the application could process a QAction with a Ctrl+S
+    // shortcut.
+    void QtEventToAzInputMapper::InitializeHighPriorityKeys()
+    {
+        m_highPriorityKeys = { Qt::Key_Alt, Qt::Key_Control, Qt::Key_Shift, Qt::Key_Super_L, Qt::Key_Super_R };
+    }
+
+    QtEventToAzInputMapper::EditorQtKeyboardDevice::EditorQtKeyboardDevice(AzFramework::InputDeviceId id)
+        : AzFramework::InputDeviceKeyboard(id)
+    {
+        // Disable all platform native processing in favor of our Qt event handling
+        SetImplementation(nullptr);
+    }
+
+    QtEventToAzInputMapper::EditorQtMouseDevice::EditorQtMouseDevice(AzFramework::InputDeviceId id)
+        : AzFramework::InputDeviceMouse(id)
+    {
+        // Disable all platform native processing in favor of our Qt event handling
+        SetImplementation(nullptr);
+    }
+
+    QtEventToAzInputMapper::QtEventToAzInputMapper(QWidget* sourceWidget, int syntheticDeviceId)
+        : QObject(sourceWidget)
+        , m_sourceWidget(sourceWidget)
+        , m_keyboardModifiers(AZStd::make_shared<AzFramework::ModifierKeyStates>())
+        , m_cursorPosition(AZStd::make_shared<AzFramework::InputChannel::PositionData2D>())
+    {
+        InitializeKeyMappings();
+        InitializeMouseButtonMappings();
+        InitializeHighPriorityKeys();
+
+        // Add an arbitrary offset to our device index to avoid collision with real physical device index.
+        // We still have to use the keyboard and mouse device channel names because input channels are only addressed
+        // by their own name and their device index, so overlapping input channels between devices would conflict.
+        constexpr AZ::u32 syntheticDeviceOffset = 1000;
+        const AzFramework::InputDeviceId keyboardDeviceId(
+            AzFramework::InputDeviceKeyboard::Id.GetName(), syntheticDeviceId + syntheticDeviceOffset);
+        const AzFramework::InputDeviceId mouseDeviceId(
+            AzFramework::InputDeviceMouse::Id.GetName(), syntheticDeviceId + syntheticDeviceOffset);
+
+        m_keyboardDevice = AZStd::make_unique<EditorQtKeyboardDevice>(keyboardDeviceId);
+        m_mouseDevice = AZStd::make_unique<EditorQtMouseDevice>(mouseDeviceId);
+
+        AddChannels(m_keyboardDevice->m_allChannelsById);
+        AddChannels(m_mouseDevice->m_allChannelsById);
+
+        // Install a global event filter to ensure we don't miss mouse and key release events.
+        QApplication::instance()->installEventFilter(this);
+    }
+
+    bool QtEventToAzInputMapper::HandlesInputEvent(const AzFramework::InputChannel& channel) const
+    {
+        const AzFramework::InputChannelId& channelId = channel.GetInputChannelId();
+        if (channelId == AzFramework::InputDeviceMouse::Movement::X || channelId == AzFramework::InputDeviceMouse::Movement::Y)
+        {
+            return false;
+        }
+
+        // We map keyboard and mouse events from Qt, so flag all events coming from those devices
+        // as handled by our synthetic event system.
+        const AzFramework::InputDeviceId& deviceId = channel.GetInputDevice().GetInputDeviceId();
+        return deviceId.GetNameCrc32() == AzFramework::InputDeviceMouse::Id.GetNameCrc32() ||
+            deviceId.GetNameCrc32() == AzFramework::InputDeviceKeyboard::Id.GetNameCrc32();
+    }
+
+    void QtEventToAzInputMapper::SetEnabled(bool enabled)
+    {
+        m_enabled = enabled;
+        if (!enabled)
+        {
+            // Send an internal focus change event to reset our input state to fresh if we're disabled.
+            HandleFocusChange(nullptr);
+        }
+    }
+
+    bool QtEventToAzInputMapper::eventFilter(QObject* object, QEvent* event)
+    {
+        // Abort if processing isn't enabled.
+        if (!m_enabled)
+        {
+            return false;
+        }
+
+        // Because there's no "end" to mouse movement and wheel events, we reset mouse movement channels that have been opened
+        // during the next processed non-mouse event.
+        if (m_mouseChannelsNeedUpdate && event->type() != QEvent::Type::MouseMove && event->type() != QEvent::Type::Wheel)
+        {
+            m_cursorPosition->m_normalizedPositionDelta = AZ::Vector2::CreateZero();
+            ProcessPendingMouseEvents();
+            m_mouseChannelsNeedUpdate = false;
+        }
+
+        // Only accept mouse & key release events that originate from an object that is not our target widget,
+        // as we don't want to erroneously intercept user input meant for another component.
+        if (object != m_sourceWidget && event->type() != QEvent::Type::KeyRelease && event->type() != QEvent::Type::MouseButtonRelease)
+        {
+            return false;
+        }
+
+        // If our focus changes, go ahead and reset all input devices.
+        if (event->type() == QEvent::FocusIn || event->type() == QEvent::FocusOut)
+        {
+            HandleFocusChange(event);
+        }
+        // Map key events to input channels.
+        // ShortcutOverride is used in lieu of KeyPress for high priority input channels like Alt
+        // that need to be accepted and stopped before they bubble up and cause unintended behavior.
+        else if (
+            event->type() == QEvent::Type::KeyPress || event->type() == QEvent::Type::KeyRelease ||
+            event->type() == QEvent::Type::ShortcutOverride)
+        {
+            QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+            HandleKeyEvent(keyEvent);
+        }
+        // Map mouse events to input channels.
+        else if (event->type() == QEvent::Type::MouseButtonPress || event->type() == QEvent::Type::MouseButtonRelease || event->type() == QEvent::Type::MouseButtonDblClick)
+        {
+            QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
+            HandleMouseButtonEvent(mouseEvent);
+        }
+        // Map mouse movement to the movement input channels.
+        // This includes SystemCursorPosition alongside Movement::X and Movement::Y.
+        else if (event->type() == QEvent::Type::MouseMove)
+        {
+            QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
+            HandleMouseMoveEvent(mouseEvent);
+        }
+        // Map wheel events to the mouse Z movement channel.
+        else if (event->type() == QEvent::Type::Wheel)
+        {
+            QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
+            HandleWheelEvent(wheelEvent);
+        }
+
+        return false;
+    }
+
+    void QtEventToAzInputMapper::NotifyUpdateChannelIfNotIdle(const AzFramework::InputChannel* channel, QEvent* event)
+    {
+        if (channel->GetState() != AzFramework::InputChannel::State::Idle)
+        {
+            emit InputChannelUpdated(channel, event);
+        }
+    }
+
+    void QtEventToAzInputMapper::ProcessPendingMouseEvents()
+    {
+        auto systemCursorChannel =
+            GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::SystemCursorPosition);
+        auto mouseWheelChannel =
+            GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Z);
+
+        systemCursorChannel->ProcessRawInputEvent(m_cursorPosition->m_normalizedPositionDelta.GetLength());
+        mouseWheelChannel->ProcessRawInputEvent(0.f);
+
+        NotifyUpdateChannelIfNotIdle(systemCursorChannel, nullptr);
+        NotifyUpdateChannelIfNotIdle(mouseWheelChannel, nullptr);
+    }
+
+    void QtEventToAzInputMapper::HandleMouseButtonEvent(QMouseEvent* mouseEvent)
+    {
+        const Qt::MouseButton button = mouseEvent->button();
+
+        if (auto buttonIt = m_mouseButtonMappings.find(button); buttonIt != m_mouseButtonMappings.end())
+        {
+            auto buttonChannel = GetInputChannel<AzFramework::InputChannelDigitalWithSharedPosition2D>(buttonIt->second);
+
+            if (buttonChannel)
+            {
+                if (mouseEvent->type() != QEvent::Type::MouseButtonRelease)
+                {
+                    buttonChannel->UpdateState(true);
+                }
+                else
+                {
+                    buttonChannel->UpdateState(false);
+                }
+
+                NotifyUpdateChannelIfNotIdle(buttonChannel, mouseEvent);
+            }
+        }
+    }
+
+    void QtEventToAzInputMapper::HandleMouseMoveEvent(QMouseEvent* mouseEvent)
+    {
+        const QPoint mousePos = mouseEvent->pos();
+        const float normalizedX = aznumeric_cast<float>(mousePos.x()) / aznumeric_cast<float>(m_sourceWidget->width());
+        const float normalizedY = aznumeric_cast<float>(mousePos.y()) / aznumeric_cast<float>(m_sourceWidget->height());
+        const AZ::Vector2 normalizedPosition(normalizedX, normalizedY);
+        m_cursorPosition->m_normalizedPositionDelta = normalizedPosition - m_cursorPosition->m_normalizedPosition;
+        m_cursorPosition->m_normalizedPosition = normalizedPosition;
+        ProcessPendingMouseEvents();
+        m_mouseChannelsNeedUpdate = true;
+    }
+
+    void QtEventToAzInputMapper::HandleKeyEvent(QKeyEvent* keyEvent)
+    {
+        // Ignore key repeat events, they're unrelated to actual physical button presses.
+        if (keyEvent->isAutoRepeat())
+        {
+            return;
+        }
+
+        const Qt::Key key = static_cast<Qt::Key>(keyEvent->key());
+
+        // For ShortcutEvent, only continue processing if we're in the HighPriorityKeys set.
+        if (keyEvent->type() != QEvent::Type::ShortcutOverride || m_highPriorityKeys.find(key) != m_highPriorityKeys.end())
+        {
+            if (auto keyIt = m_keyMappings.find(key); keyIt != m_keyMappings.end())
+            {
+                auto keyChannel = GetInputChannel<AzFramework::InputChannelDigitalWithSharedModifierKeyStates>(keyIt->second);
+
+                if (keyChannel)
+                {
+                    if (keyEvent->type() == QEvent::Type::KeyPress || keyEvent->type() == QEvent::Type::ShortcutOverride)
+                    {
+                        keyChannel->UpdateState(true);
+                    }
+                    else
+                    {
+                        keyChannel->UpdateState(false);
+                    }
+
+                    NotifyUpdateChannelIfNotIdle(keyChannel, keyEvent);
+                }
+            }
+        }
+    }
+
+    void QtEventToAzInputMapper::HandleWheelEvent(QWheelEvent* wheelEvent)
+    {
+        auto cursorZChannel =
+            GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Z);
+        const QPoint angleDelta = wheelEvent->angleDelta();
+        // Check both angles, as the alt modifier can change the wheel direction.
+        int wheelAngle = angleDelta.x();
+        if (wheelAngle == 0)
+        {
+            wheelAngle = angleDelta.y();
+        }
+        cursorZChannel->ProcessRawInputEvent(aznumeric_cast<float>(wheelAngle));
+        NotifyUpdateChannelIfNotIdle(cursorZChannel, wheelEvent);
+        m_mouseChannelsNeedUpdate = true;
+    }
+
+    void QtEventToAzInputMapper::HandleFocusChange(QEvent* event)
+    {
+        for (auto& channelData : m_channels)
+        {
+            // If resetting the input device changed the channel state, submit it to the mapped channel list
+            // for processing.
+            if (channelData.second->IsActive())
+            {
+                channelData.second->UpdateState(false);
+                NotifyUpdateChannelIfNotIdle(channelData.second, event);
+            }
+        }
+        m_mouseChannelsNeedUpdate = false;
+    }
+} // namespace AzToolsFramework
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ * 
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#if !defined(Q_MOC_RUN)
+#include <AzCore/std/smart_ptr/shared_ptr.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
+#include <AzFramework/Input/Channels/InputChannel.h>
+#include <AzFramework/Input/Channels/InputChannelDeltaWithSharedPosition2D.h>
+#include <AzFramework/Input/Channels/InputChannelDigitalWithSharedModifierKeyStates.h>
+#include <AzFramework/Input/Channels/InputChannelDigitalWithSharedPosition2D.h>
+
+#include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
+#include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
+
+#include <QEvent>
+#include <QObject>
+#endif //! defined(Q_MOC_RUN)
+
+class QWidget;
+class QKeyEvent;
+class QMouseEvent;
+class QWheelEvent;
+
+namespace AzToolsFramework
+{
+    //! Maps events from the Qt input system to synthetic InputChannels in AzFramework
+    //! that can be used by AzFramework::ViewportControllers.
+    class QtEventToAzInputMapper final : public QObject
+    {
+        Q_OBJECT
+
+    public:
+        QtEventToAzInputMapper(QWidget* sourceWidget, int syntheticDeviceId = 0);
+        ~QtEventToAzInputMapper() = default;
+
+        //! Queries whether a given input channel has a synthetic equivalent mapped
+        //! by this system.
+        //! \returns true if the channel is handled by MapQtEventToAzInput.
+        bool HandlesInputEvent(const AzFramework::InputChannel& channel) const;
+
+        //! Sets whether or not this input mapper should be updating its input channels from Qt events.
+        void SetEnabled(bool enabled);
+
+        // QObject overrides...
+        bool eventFilter(QObject* object, QEvent* event) override;
+
+    signals:
+        //! This signal fires whenever the state of the specified input channel changes.
+        //! This is determined by Qt events dispatched to the source widget.
+        //! \param channel The AZ input channel that has been updated.
+        //! \param event The underlying Qt event that triggered this change, if applicable.
+        void InputChannelUpdated(const AzFramework::InputChannel* channel, QEvent* event);
+
+    private:
+        // Gets an input channel of the specified type by ID.
+        template<class TInputChannel>
+        TInputChannel* GetInputChannel(const AzFramework::InputChannelId& id)
+        {
+            auto channelIt = m_channels.find(id);
+            if (channelIt != m_channels.end())
+            {
+                return static_cast<TInputChannel*>(channelIt->second);
+            }
+            return nullptr;
+        }
+
+        // Adds channels from the specified channel container to our input channel ID -> input channel lookup table.
+        // Used for rapid lookup.
+        template <class TContainer>
+        void AddChannels(const TContainer& container)
+        {
+            for (const auto& channelData : container)
+            {
+                // Break const as we're taking these input channels from devices we own.
+                m_channels.emplace(channelData.first, const_cast<AzFramework::InputChannel*>(channelData.second));
+            }
+        }
+
+        // Our synthetic Keyboard device, does no internal keyboard handling and instead listens to this class for updates.
+        class EditorQtKeyboardDevice : public AzFramework::InputDeviceKeyboard
+        {
+        public:
+            EditorQtKeyboardDevice(AzFramework::InputDeviceId id);
+
+            friend class QtEventToAzInputMapper;
+        };
+
+        // Our synthetic Mouse device, does no internal keyboard handling and instead listens to this class for updates.
+        class EditorQtMouseDevice : public AzFramework::InputDeviceMouse
+        {
+        public:
+            EditorQtMouseDevice(AzFramework::InputDeviceId id);
+
+            friend class QtEventToAzInputMapper;
+        };
+
+        // Emits InputChannelUpdated if channel has transitioned in state (i.e. has gone from active to inactive or vice versa).
+        void NotifyUpdateChannelIfNotIdle(const AzFramework::InputChannel* channel, QEvent* event);
+
+        // Processes any pending mouse movement events, this allows mouse movement channels to close themselves.
+        void ProcessPendingMouseEvents();
+
+        // Handle mouse click events.
+        void HandleMouseButtonEvent(QMouseEvent* mouseEvent);
+        // Handle mouse move events.
+        void HandleMouseMoveEvent(QMouseEvent* mouseEvent);
+        // Handles key press / release events (or ShortcutOverride events for keys listed in m_highPriorityKeys).
+        void HandleKeyEvent(QKeyEvent* keyEvent);
+        // Handles mouse wheel events.
+        void HandleWheelEvent(QWheelEvent* wheelEvent);
+        // Handles focus change events.
+        void HandleFocusChange(QEvent* event);
+
+        // Populates m_keyMappings.
+        void InitializeKeyMappings();
+        // Populates m_mouseButtonMappings.
+        void InitializeMouseButtonMappings();
+        // Populates m_highPriorityKeys.
+        void InitializeHighPriorityKeys();
+
+        // The current keyboard modifier state used by our synthetic key input channels.
+        AZStd::shared_ptr<AzFramework::ModifierKeyStates> m_keyboardModifiers;
+        // The current normalized cursor position used by our synthetic system cursor event.
+        AZStd::shared_ptr<AzFramework::InputChannel::PositionData2D> m_cursorPosition;
+        // A lookup table for Qt key -> AZ input channel.
+        AZStd::unordered_map<Qt::Key, AzFramework::InputChannelId> m_keyMappings;
+        // A lookup table for Qt mouse button -> AZ input channel.
+        AZStd::unordered_map<Qt::MouseButton, AzFramework::InputChannelId> m_mouseButtonMappings;
+        // A set of high priority keys that need to be processed at the ShortcutOverride level instead of the
+        // KeyEvent level. This prevents e.g. the main menu bar from processing a press of the "alt" key when the
+        // viewport consumes the event.
+        AZStd::unordered_set<Qt::Key> m_highPriorityKeys;
+        // A lookup table for AZ input channel ID -> physical input channel on our mouse or keyboard device.
+        AZStd::unordered_map<AzFramework::InputChannelId, AzFramework::InputChannel*> m_channels;
+        // The source widget to map events from, used to calculate the relative mouse position within the widget bounds.
+        QWidget* m_sourceWidget;
+        // Flags when mouse movement channels have been opened and may need to be closed (as there are no movement ended events).
+        bool m_mouseChannelsNeedUpdate = false;
+        // Flags whether or not Qt events should currently be processed.
+        bool m_enabled = true;
+
+        // Our viewport-specific AZ devices. We control their internal input channel states.
+        AZStd::unique_ptr<EditorQtMouseDevice> m_mouseDevice;
+        AZStd::unique_ptr<EditorQtKeyboardDevice> m_keyboardDevice;
+    };
+} // namespace AzToolsFramework
@@ -724,6 +724,8 @@ set(FILES
    PythonTerminal/ScriptTermDialog.cpp
    PythonTerminal/ScriptTermDialog.h
    PythonTerminal/ScriptTermDialog.ui
+    Input/QtEventToAzInputManager.h
+    Input/QtEventToAzInputManager.cpp
 )

 # Prevent the following files from being grouped in UNITY builds
@@ -11,6 +11,7 @@
 #include <QElapsedTimer>
 #include <Atom/RPI.Public/Base.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
+#include <AzToolsFramework/Input/QtEventToAzInputManager.h>
 #include <AzFramework/Input/Events/InputChannelEventListener.h>
 #include <AzFramework/Scene/Scene.h>
 #include <AzFramework/Viewport/ViewportControllerInterface.h>
@@ -81,6 +82,12 @@ namespace AtomToolsFramework
        //! Gets the default camera that's been automatically registered to our ViewportContext.
        AZ::RPI::ViewPtr GetDefaultCamera();
        AZ::RPI::ConstViewPtr GetDefaultCamera() const;
+        //! Sets whether or not input processing is enabled for this RenderViewportWidget.
+        //! While input processing is enabled, synthetic input events may appear in OnInputChannelEventFiltered
+        //! due to internal viewport input mapping via QtEventToAzInputMapper, so it may be desirable to disable
+        //! camera controller input processing wholesale to avoid competing input messages.
+        //! Input processing is enabled by default.
+        void SetInputProcessingEnabled(bool enabled);

        // AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus::Handler ...
        AzFramework::CameraState GetCameraState() override;
@@ -130,7 +137,6 @@ namespace AtomToolsFramework

    private:
        void SendWindowResizeEvent();
-        bool CanInputGrantFocus(const AzFramework::InputChannel& inputChannel) const;

        // The underlying ViewportContext, our entry-point to the Atom RPI.
        AZ::RPI::ViewportContextPtr m_viewportContext;
@@ -157,5 +163,7 @@ namespace AtomToolsFramework
        AZStd::optional<QPoint> m_lastCursorPosition;
        // The viewport settings (e.g. grid snapping, grid size) for this viewport.
        const AzToolsFramework::ViewportInteraction::ViewportSettings* m_viewportSettings = nullptr;
+        // Maps our internal Qt events into AzFramework InputChannels for our ViewportControllerList.
+        AzToolsFramework::QtEventToAzInputMapper* m_inputChannelMapper = nullptr;
    };
 } //namespace AtomToolsFramework
@@ -81,6 +81,23 @@ namespace AtomToolsFramework
        AZ::TickBus::Handler::BusConnect();
        AzFramework::WindowRequestBus::Handler::BusConnect(params.windowHandle);

+        m_inputChannelMapper = new AzToolsFramework::QtEventToAzInputMapper(this, id);
+
+        // Forward input events to our controller list.
+        QObject::connect(m_inputChannelMapper, &AzToolsFramework::QtEventToAzInputMapper::InputChannelUpdated, this,
+            [this](const AzFramework::InputChannel* inputChannel, QEvent* event)
+        {
+            AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
+            if (m_controllerList->HandleInputChannelEvent({GetId(), windowId, *inputChannel}))
+            {
+                // If the controller handled the input event, mark the event as accepted so it doesn't continue to propagate.
+                if (event)
+                {
+                    event->setAccepted(true);
+                }
+            }
+        });
+
        return true;
    }

@@ -149,86 +166,24 @@ namespace AtomToolsFramework
        return m_defaultCamera;
    }

-    static bool IsMouseButtonEvent(const AzFramework::InputChannel& inputChannel)
-    {
-        const auto& mouseButtons = AzFramework::InputDeviceMouse::Button::All;
-        return AZStd::find(mouseButtons.begin(), mouseButtons.end(), inputChannel.GetInputChannelId()) != mouseButtons.end();
-    }
-
-    static bool IsMouseMoveEvent(const AzFramework::InputChannel& inputChannel)
-    {
-        return inputChannel.GetInputChannelId() == AzFramework::InputDeviceMouse::SystemCursorPosition;
-    }
-
-    static bool IsMouseButtonOrWheelEvent(const AzFramework::InputChannel& inputChannel)
-    {
-        return IsMouseButtonEvent(inputChannel) || inputChannel.GetInputChannelId() == AzFramework::InputDeviceMouse::Movement::Z;
-    }
-
-    bool RenderViewportWidget::CanInputGrantFocus(const AzFramework::InputChannel& inputChannel) const
-    {
-        // Only take focus from a mouse event if the cursor is currently within the viewport
-        if (!m_mouseOver)
-        {
-            return false;
-        }
-
-        // Only mouse button down events (clicks) can grant focus
-        if (inputChannel.GetState() != AzFramework::InputChannel::State::Began)
-        {
-            return false;
-        }
-
-        // Only mouse button events can grant focus
-        return IsMouseButtonEvent(inputChannel);
-    }
-
    bool RenderViewportWidget::OnInputChannelEventFiltered(const AzFramework::InputChannel& inputChannel)
    {
-        bool shouldConsumeEvent = true;
-
-        // Grab keyboard focus if we've been clicked on.
-        // Qt normally handles this for us, but we're filtering native events before they get
-        // synthesized into QMouseEvents.
-        if (!hasFocus() && CanInputGrantFocus(inputChannel))
-        {
-            setFocus();
-        }
-
-        // Don't consume new input events if we don't currently have focus.
-        // We do forward Ended events, as they may be relevant to our current state
-        // (e.g. a key gets released after we lose focus, it shouldn't remain "stuck").
        if (!hasFocus())
        {
-            if (inputChannel.GetState() == AzFramework::InputChannel::State::Ended)
-            {
-                // Forward the input ended event to our controllers, but don't prevent other viewports from receiving it.
-                shouldConsumeEvent = false;
-            }
-            else
-            {
-                // Not an event we should listen to, abort.
-                return false;
-            }
+            return false;
        }

-        // If we receive a mouse button event from outside of our viewport, ignore it even if we have focus.
-        if (!m_mouseOver
-            && inputChannel.GetState() == AzFramework::InputChannel::State::Began
-            && IsMouseButtonOrWheelEvent(inputChannel))
+        // Only forward channels that aren't covered by our Qt -> AZ event mapper
+        if (!m_inputChannelMapper || m_inputChannelMapper->HandlesInputEvent(inputChannel))
        {
            return false;
        }

-        // Don't forward system cursor position updates, we'll do that ourselves for in-window movements once the result of
-        // ViewportCursorScreenPosition is guaranteed to be correct (see mouseMoveEvent).
-        if (IsMouseMoveEvent(inputChannel))
-        {
-            return false;
-        }
+        bool shouldConsumeEvent = true;

        AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
        const bool eventHandled = m_controllerList->HandleInputChannelEvent({GetId(), windowId, inputChannel});
+
        // If our controllers handled the event and it's one we can safely consume (i.e. it's not an Ended event that other viewports might need), consume it.
        return eventHandled && shouldConsumeEvent;
    }
@@ -262,6 +217,7 @@ namespace AtomToolsFramework
        {
            SendWindowResizeEvent();
        }
+
        return QWidget::event(event);
    }

@@ -279,23 +235,12 @@ namespace AtomToolsFramework
    {
        m_mousePosition = event->localPos();

-        // Now that we've looked a viewport local mouse position,
-        // we can go ahead and broadcast the system cursor input event to the controllers.
-        // This allows any controllers not listening to pure mouse deltas to consistently
-        // look up the mouse position in viewport screen coordinates.
-        const AzFramework::InputDevice* mouseInputDevice = nullptr;
-        if (AzFramework::InputDeviceRequestBus::EventResult(
-                mouseInputDevice, AzFramework::InputDeviceMouse::Id, &AzFramework::InputDeviceRequests::GetInputDevice);
-            mouseInputDevice != nullptr)
-        {
-            const AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
-            AzFramework::InputChannel syntheticInput(AzFramework::InputDeviceMouse::SystemCursorPosition, *mouseInputDevice);
-            m_controllerList->HandleInputChannelEvent({GetId(), windowId, syntheticInput});
-        }
-
        if (m_capturingCursor && m_lastCursorPosition.has_value())
        {
            AzQtComponents::SetCursorPos(m_lastCursorPosition.value());
+            // Even though we just set the cursor position, there are edge cases such as remote desktop that will leave
+            // the cursor position unchanged. For safety, we re-cache our last cursor position for delta generation.
+            m_lastCursorPosition = QCursor::pos();
        }
        else
        {
@@ -354,6 +299,12 @@ namespace AtomToolsFramework
        }
    }

+    void RenderViewportWidget::SetInputProcessingEnabled(bool enabled)
+    {
+        m_inputChannelMapper->SetEnabled(enabled);
+        m_controllerList->SetEnabled(enabled);
+    }
+
    AzFramework::CameraState RenderViewportWidget::GetCameraState()
    {
        AZ::RPI::ViewPtr currentView = m_viewportContext->GetDefaultView();