Merge branch 'development' of https://github.com/o3de/o3de into jckand/DynVegXfailFixes
jckand-amzn
5 years ago
commit
c64f3fa5f9
@ -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
|
||||
Loading…
Reference in New Issue