592 lines
24 KiB
C#
592 lines
24 KiB
C#
using Nova;
|
|
using UnityEngine;
|
|
#if !ENABLE_LEGACY_INPUT_MANAGER
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.InputSystem.EnhancedTouch;
|
|
using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
|
|
using TouchPhase = UnityEngine.InputSystem.TouchPhase;
|
|
#endif
|
|
|
|
namespace NovaSamples.UIControls
|
|
{
|
|
/// <summary>
|
|
/// Simple input manager example for the UI Controls sample.
|
|
/// </summary>
|
|
public class InputManager : MonoBehaviour
|
|
{
|
|
/// <summary>
|
|
/// Fired after mouse clicks. Can be used to determine when focus is lost.
|
|
/// </summary>
|
|
public static System.Action<UIBlock> OnPostClick;
|
|
|
|
[SerializeField]
|
|
[Tooltip("The camera to use for mouse and touch input.")]
|
|
private Camera cam = null;
|
|
|
|
[Header("Mouse")]
|
|
[SerializeField]
|
|
[Tooltip("Handle mouse input events.")]
|
|
private bool mouseEnabled = true;
|
|
[SerializeField]
|
|
[Tooltip("Inverts the mouse wheel scroll direction.")]
|
|
private bool invertScrolling = true;
|
|
|
|
[Header("Touch")]
|
|
[SerializeField]
|
|
[Tooltip("Handle touch input events.")]
|
|
private bool touchEnabled = true;
|
|
|
|
[Header("Navigation")]
|
|
[SerializeField]
|
|
[Tooltip("Handle navigation input events.")]
|
|
private bool navigationEnabled = false;
|
|
[SerializeField]
|
|
[Tooltip("The starting point for navigation focus.")]
|
|
private GestureRecognizer startNavigationFrom = null;
|
|
[Tooltip("The UIBlock to move around as navigation focus changes. Will be created if null.")]
|
|
public UIBlock NavigationIndicator = null;
|
|
[SerializeField]
|
|
[Tooltip("Move navigation focus at this rate (in seconds) while its corresponding key is pressed.")]
|
|
private float updateNavigationEveryXSeconds = 0.25f;
|
|
|
|
[Header("Navigation Keys")]
|
|
public KeyCode UpKey = KeyCode.UpArrow;
|
|
public KeyCode DownKey = KeyCode.DownArrow;
|
|
public KeyCode LeftKey = KeyCode.LeftArrow;
|
|
public KeyCode RightKey = KeyCode.RightArrow;
|
|
public KeyCode SelectKey = KeyCode.Return;
|
|
public KeyCode DeselectKey = KeyCode.Escape;
|
|
|
|
/// <summary>
|
|
/// The camera to use for mouse and touch input.
|
|
/// </summary>
|
|
public Camera Cam
|
|
{
|
|
get => cam;
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
Debug.LogError("Provided Camera is null. Please assign a valid Camera.", this);
|
|
return;
|
|
}
|
|
|
|
cam = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle mouse input events.
|
|
/// </summary>
|
|
public bool MouseEnabled
|
|
{
|
|
get => mouseEnabled;
|
|
set => mouseEnabled = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle touch input events.
|
|
/// </summary>
|
|
public bool TouchEnabled
|
|
{
|
|
get => touchEnabled;
|
|
set => touchEnabled = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle navigation input events.
|
|
/// </summary>
|
|
public bool NavigationEnabled
|
|
{
|
|
get => navigationEnabled;
|
|
set => navigationEnabled = value;
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
if (cam == null)
|
|
{
|
|
cam = Camera.current;
|
|
}
|
|
|
|
if (cam == null)
|
|
{
|
|
cam = Camera.main;
|
|
}
|
|
|
|
Navigation.OnNavigationFocusChanged += HandleNavigationFocusChanged;
|
|
|
|
#if !ENABLE_LEGACY_INPUT_MANAGER
|
|
EnhancedTouchSupport.Enable();
|
|
#endif
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
Navigation.OnNavigationFocusChanged -= HandleNavigationFocusChanged;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
UpdateMouse();
|
|
UpdateTouch();
|
|
UpdateNavigation();
|
|
}
|
|
|
|
#region Mouse
|
|
private const uint MousePointerControlID = 1;
|
|
private const uint ScrollWheelControlID = 2;
|
|
|
|
#if ENABLE_LEGACY_INPUT_MANAGER
|
|
private bool MousePresent => Input.mousePresent;
|
|
private Vector2 MousePosition => Input.mousePosition;
|
|
private Vector2 MouseScrollDelta => Input.mouseScrollDelta;
|
|
private bool LeftMouseButtonValue => Input.GetMouseButton(0);
|
|
private bool LeftMouseButtonUp => Input.GetMouseButtonUp(0);
|
|
#else
|
|
private bool MousePresent => Mouse.current != null;
|
|
private Vector2 MousePosition => Mouse.current.position.ReadValue();
|
|
private Vector2 MouseScrollDelta => Mouse.current.scroll.ReadValue().normalized;
|
|
private bool LeftMouseButtonValue => Mouse.current.leftButton.isPressed;
|
|
private bool LeftMouseButtonUp => Mouse.current.leftButton.wasReleasedThisFrame;
|
|
#endif
|
|
|
|
private void UpdateMouse()
|
|
{
|
|
if (cam == null || !mouseEnabled || !MousePresent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get the current world-space ray of the mouse
|
|
Ray mouseRay = cam.ScreenPointToRay(MousePosition);
|
|
|
|
// Get the current scroll wheel delta
|
|
Vector2 mouseScrollDelta = MouseScrollDelta;
|
|
|
|
if (mouseScrollDelta != Vector2.zero)
|
|
{
|
|
// Invert scrolling for a mouse-type experience,
|
|
// otherwise will scroll track-pad style.
|
|
if (invertScrolling)
|
|
{
|
|
mouseScrollDelta.y *= -1f;
|
|
}
|
|
|
|
// Create a new Interaction.Update from the mouse ray and scroll wheel control id
|
|
Interaction.Update scrollInteraction = new Interaction.Update(mouseRay, ScrollWheelControlID);
|
|
|
|
// Feed the scroll update and scroll delta into Nova's Interaction APIs
|
|
Interaction.Scroll(scrollInteraction, mouseScrollDelta);
|
|
}
|
|
|
|
// Create a new Interaction.Update from the mouse ray and pointer control id
|
|
Interaction.Update pointInteraction = new Interaction.Update(mouseRay, MousePointerControlID);
|
|
|
|
// Feed the pointer update and pressed state to Nova's Interaction APIs
|
|
Interaction.Point(pointInteraction, LeftMouseButtonValue);
|
|
|
|
if (LeftMouseButtonUp)
|
|
{
|
|
// If the mouse button was released this frame, fire the OnPostClick
|
|
// event with the hit UIBlock (or null if there wasn't one)
|
|
Interaction.TryGetActiveReceiver(MousePointerControlID, out UIBlockHit hit);
|
|
OnPostClick?.Invoke(hit.UIBlock);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Touch
|
|
|
|
#if ENABLE_LEGACY_INPUT_MANAGER
|
|
private bool TouchSupported => Input.touchSupported;
|
|
private int TouchCount => Input.touchCount;
|
|
private Touch GetTouch(int index) => Input.GetTouch(index);
|
|
private Vector2 GetTouchPosition(Touch touch) => touch.position;
|
|
private uint GetTouchID(Touch touch) => (uint)touch.fingerId;
|
|
#else
|
|
private bool TouchSupported => Touchscreen.current != null;
|
|
private int TouchCount => Touch.activeTouches.Count;
|
|
private Touch GetTouch(int index) => Touch.activeTouches[index];
|
|
private Vector2 GetTouchPosition(Touch touch) => touch.screenPosition;
|
|
private uint GetTouchID(Touch touch) => (uint)touch.finger.index;
|
|
#endif
|
|
|
|
private void UpdateTouch()
|
|
{
|
|
if (cam == null || !touchEnabled || !TouchSupported)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < TouchCount; i++)
|
|
{
|
|
Touch touch = GetTouch(i);
|
|
|
|
// Convert the touch point to a world-space ray.
|
|
Ray ray = cam.ScreenPointToRay(GetTouchPosition(touch));
|
|
|
|
// Create a new Interaction from the ray and the finger's ID
|
|
Interaction.Update update = new Interaction.Update(ray, GetTouchID(touch));
|
|
|
|
// Get the current touch phase
|
|
TouchPhase touchPhase = touch.phase;
|
|
|
|
// If the touch phase hasn't ended and hasn't been canceled, then pointerDown == true.
|
|
bool pointerDown = touchPhase != TouchPhase.Canceled && touchPhase != TouchPhase.Ended;
|
|
|
|
// Feed the update and pressed state to Nova's Interaction APIs
|
|
Interaction.Point(update, pointerDown);
|
|
|
|
if (!pointerDown)
|
|
{
|
|
// If the finger is off the screen, send a follow up hover that
|
|
// won't hit anything and cancel to indicate the interaction is over.
|
|
// This is to assist with cross platform compatibility for hover events,
|
|
// since touch events are driven by press/release and don't provide the same
|
|
// kind of "pointer exit" data as an unpressed mouse pointer
|
|
update.Ray = default;
|
|
Interaction.Point(update, false);
|
|
Interaction.Cancel(update);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Navigation
|
|
#if ENABLE_LEGACY_INPUT_MANAGER
|
|
private bool KeyboardPresent => true;
|
|
private bool NavigateUp => Input.GetKey(UpKey);
|
|
private bool NavigateDown => Input.GetKey(DownKey);
|
|
private bool NavigateLeft => Input.GetKey(LeftKey);
|
|
private bool NavigateRight => Input.GetKey(RightKey);
|
|
private bool Select => Input.GetKeyUp(SelectKey);
|
|
private bool Deselect => Input.GetKeyUp(DeselectKey);
|
|
#else
|
|
private bool KeyboardPresent => Keyboard.current != null;
|
|
private bool NavigateUp => Keyboard.current[GetKey(UpKey)].isPressed;
|
|
private bool NavigateDown => Keyboard.current[GetKey(DownKey)].isPressed;
|
|
private bool NavigateLeft => Keyboard.current[GetKey(LeftKey)].isPressed;
|
|
private bool NavigateRight => Keyboard.current[GetKey(RightKey)].isPressed;
|
|
private bool Select => Keyboard.current[GetKey(SelectKey)].wasReleasedThisFrame;
|
|
private bool Deselect => Keyboard.current[GetKey(DeselectKey)].wasReleasedThisFrame;
|
|
#endif
|
|
private const uint NavigationID = 3;
|
|
private float prevNavTime = 0;
|
|
|
|
private void UpdateNavigation()
|
|
{
|
|
bool canNavigate = navigationEnabled && KeyboardPresent;
|
|
bool navigating = Navigation.TryGetFocusedUIBlock(NavigationID, out UIBlock focused);
|
|
|
|
if (canNavigate && !navigating)
|
|
{
|
|
// Initialize navigation
|
|
EnsureNavigationIndicator();
|
|
|
|
if (startNavigationFrom != null)
|
|
{
|
|
Navigation.Focus(startNavigationFrom.UIBlock, NavigationID);
|
|
}
|
|
}
|
|
|
|
if (NavigationIndicator != null)
|
|
{
|
|
// Ensure visibility matches navigable status
|
|
NavigationIndicator.gameObject.SetActive(canNavigate && navigating);
|
|
}
|
|
|
|
if (!canNavigate || !navigating)
|
|
{
|
|
// Not navigable
|
|
return;
|
|
}
|
|
|
|
Vector3 navDirection = Vector3.zero;
|
|
|
|
float timeSinceNav = Time.unscaledTime - prevNavTime;
|
|
|
|
if (NavigateDown)
|
|
{
|
|
navDirection += Vector3.down;
|
|
}
|
|
|
|
if (NavigateUp)
|
|
{
|
|
navDirection += Vector3.up;
|
|
}
|
|
|
|
if (NavigateRight)
|
|
{
|
|
navDirection += Vector3.right;
|
|
}
|
|
|
|
if (NavigateLeft)
|
|
{
|
|
navDirection += Vector3.left;
|
|
}
|
|
|
|
if (navDirection == Vector3.zero)
|
|
{
|
|
// if no navigation key is pressed,
|
|
// "reset" prevNavTime.
|
|
prevNavTime = Time.unscaledTime - updateNavigationEveryXSeconds;
|
|
}
|
|
|
|
if (navDirection != Vector3.zero)
|
|
{
|
|
if (timeSinceNav > updateNavigationEveryXSeconds)
|
|
{
|
|
prevNavTime = Time.unscaledTime;
|
|
Navigation.Move(navDirection, NavigationID);
|
|
}
|
|
}
|
|
else if (Deselect)
|
|
{
|
|
Navigation.Deselect(NavigationID);
|
|
}
|
|
else if (Select)
|
|
{
|
|
Navigation.Select(NavigationID);
|
|
}
|
|
|
|
if (focused == null)
|
|
{
|
|
// Nothing to update
|
|
return;
|
|
}
|
|
|
|
// Match the world scale of the focused element
|
|
Vector3 parentScale = NavigationIndicator.transform.parent == null ? Vector3.one : NavigationIndicator.transform.parent.lossyScale;
|
|
Vector3 focusedScale = focused.transform.lossyScale;
|
|
NavigationIndicator.transform.localScale = new Vector3(focusedScale.x / parentScale.x, focusedScale.y / parentScale.y, focusedScale.z / parentScale.z);
|
|
|
|
// Update size and position to match whatever's focused
|
|
NavigationIndicator.Size = focused.CalculatedSize.Value + NavigationIndicator.CalculatedPadding.Size;
|
|
NavigationIndicator.TrySetWorldPosition(focused.transform.position);
|
|
NavigationIndicator.transform.rotation = focused.transform.rotation;
|
|
}
|
|
|
|
private void HandleNavigationFocusChanged(uint controlID, UIBlock focused)
|
|
{
|
|
// When navigation focus changes, treat that
|
|
// as though something new was clicked, since
|
|
// we're no longer "hovering" on the previously
|
|
// focused element.
|
|
OnPostClick?.Invoke(focused);
|
|
}
|
|
|
|
private void EnsureNavigationIndicator()
|
|
{
|
|
if (NavigationIndicator != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Create a new game object to be our focus indicator
|
|
UIBlock2D indicator = new GameObject("Navigation Indicator").AddComponent<UIBlock2D>();
|
|
|
|
// Hide the body and enable the border
|
|
indicator.BodyEnabled = false;
|
|
indicator.Border = new Border()
|
|
{
|
|
Enabled = true,
|
|
Width = 5,
|
|
Direction = BorderDirection.Out,
|
|
Color = Color.yellow,
|
|
};
|
|
|
|
// Round the cornes a bit
|
|
indicator.CornerRadius = 2;
|
|
|
|
// Add some padding
|
|
indicator.Padding.XY = 5;
|
|
|
|
// Make sure the indicator will render over the other content
|
|
SortGroup sortGroup = indicator.gameObject.AddComponent<SortGroup>();
|
|
sortGroup.RenderQueue = 4001;
|
|
sortGroup.RenderOverOpaqueGeometry = true;
|
|
|
|
// assign the focus indicator
|
|
NavigationIndicator = indicator;
|
|
}
|
|
|
|
#region Convert KeyCode to Key
|
|
#if !ENABLE_LEGACY_INPUT_MANAGER
|
|
/// <summary>
|
|
/// Attempts to convert the legacy KeyCode value to its corresponding Key value
|
|
///
|
|
/// Code was taken from https://forum.unity.com/threads/convert-from-old-keycode-to-the-new-key-enum.938459/
|
|
/// </summary>
|
|
/// <param name="keyCode">The <see cref="KeyCode"/> to convert to an <see cref="UnityEngine.InputSystem.Key"/></param>
|
|
/// <returns></returns>
|
|
public static Key GetKey(KeyCode keyCode)
|
|
{
|
|
Key unknownKey = Key.None;
|
|
Key mouseKey = Key.None;
|
|
Key joystickKey = Key.None;
|
|
|
|
switch (keyCode)
|
|
{
|
|
case KeyCode.None: return Key.None;
|
|
case KeyCode.Backspace: return Key.Backspace;
|
|
case KeyCode.Delete: return Key.Delete;
|
|
case KeyCode.Tab: return Key.Tab;
|
|
case KeyCode.Clear: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Return: return Key.Enter;
|
|
case KeyCode.Pause: return Key.Pause;
|
|
case KeyCode.Escape: return Key.Escape;
|
|
case KeyCode.Space: return Key.Space;
|
|
case KeyCode.Keypad0: return Key.Numpad0;
|
|
case KeyCode.Keypad1: return Key.Numpad1;
|
|
case KeyCode.Keypad2: return Key.Numpad2;
|
|
case KeyCode.Keypad3: return Key.Numpad3;
|
|
case KeyCode.Keypad4: return Key.Numpad4;
|
|
case KeyCode.Keypad5: return Key.Numpad5;
|
|
case KeyCode.Keypad6: return Key.Numpad6;
|
|
case KeyCode.Keypad7: return Key.Numpad7;
|
|
case KeyCode.Keypad8: return Key.Numpad8;
|
|
case KeyCode.Keypad9: return Key.Numpad9;
|
|
case KeyCode.KeypadPeriod: return Key.NumpadPeriod;
|
|
case KeyCode.KeypadDivide: return Key.NumpadDivide;
|
|
case KeyCode.KeypadMultiply: return Key.NumpadMultiply;
|
|
case KeyCode.KeypadMinus: return Key.NumpadMinus;
|
|
case KeyCode.KeypadPlus: return Key.NumpadPlus;
|
|
case KeyCode.KeypadEnter: return Key.NumpadEnter;
|
|
case KeyCode.KeypadEquals: return Key.NumpadEquals;
|
|
case KeyCode.UpArrow: return Key.UpArrow;
|
|
case KeyCode.DownArrow: return Key.DownArrow;
|
|
case KeyCode.RightArrow: return Key.RightArrow;
|
|
case KeyCode.LeftArrow: return Key.LeftArrow;
|
|
case KeyCode.Insert: return Key.Insert;
|
|
case KeyCode.Home: return Key.Home;
|
|
case KeyCode.End: return Key.End;
|
|
case KeyCode.PageUp: return Key.PageUp;
|
|
case KeyCode.PageDown: return Key.PageDown;
|
|
case KeyCode.F1: return Key.F1;
|
|
case KeyCode.F2: return Key.F2;
|
|
case KeyCode.F3: return Key.F3;
|
|
case KeyCode.F4: return Key.F4;
|
|
case KeyCode.F5: return Key.F5;
|
|
case KeyCode.F6: return Key.F6;
|
|
case KeyCode.F7: return Key.F7;
|
|
case KeyCode.F8: return Key.F8;
|
|
case KeyCode.F9: return Key.F9;
|
|
case KeyCode.F10: return Key.F10;
|
|
case KeyCode.F11: return Key.F11;
|
|
case KeyCode.F12: return Key.F12;
|
|
case KeyCode.F13: return unknownKey; // Conversion unknown.
|
|
case KeyCode.F14: return unknownKey; // Conversion unknown.
|
|
case KeyCode.F15: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Alpha0: return Key.Digit0;
|
|
case KeyCode.Alpha1: return Key.Digit1;
|
|
case KeyCode.Alpha2: return Key.Digit2;
|
|
case KeyCode.Alpha3: return Key.Digit3;
|
|
case KeyCode.Alpha4: return Key.Digit4;
|
|
case KeyCode.Alpha5: return Key.Digit5;
|
|
case KeyCode.Alpha6: return Key.Digit6;
|
|
case KeyCode.Alpha7: return Key.Digit7;
|
|
case KeyCode.Alpha8: return Key.Digit8;
|
|
case KeyCode.Alpha9: return Key.Digit9;
|
|
case KeyCode.Exclaim: return unknownKey; // Conversion unknown.
|
|
case KeyCode.DoubleQuote: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Hash: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Dollar: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Percent: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Ampersand: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Quote: return Key.Quote;
|
|
case KeyCode.LeftParen: return unknownKey; // Conversion unknown.
|
|
case KeyCode.RightParen: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Asterisk: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Plus: return Key.None; // TODO
|
|
case KeyCode.Comma: return Key.Comma;
|
|
case KeyCode.Minus: return Key.Minus;
|
|
case KeyCode.Period: return Key.Period;
|
|
case KeyCode.Slash: return Key.Slash;
|
|
case KeyCode.Colon: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Semicolon: return Key.Semicolon;
|
|
case KeyCode.Less: return Key.None;
|
|
case KeyCode.Equals: return Key.Equals;
|
|
case KeyCode.Greater: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Question: return unknownKey; // Conversion unknown.
|
|
case KeyCode.At: return unknownKey; // Conversion unknown.
|
|
case KeyCode.LeftBracket: return Key.LeftBracket;
|
|
case KeyCode.Backslash: return Key.Backslash;
|
|
case KeyCode.RightBracket: return Key.RightBracket;
|
|
case KeyCode.Caret: return Key.None; // TODO
|
|
case KeyCode.Underscore: return unknownKey; // Conversion unknown.
|
|
case KeyCode.BackQuote: return Key.Backquote;
|
|
case KeyCode.A: return Key.A;
|
|
case KeyCode.B: return Key.B;
|
|
case KeyCode.C: return Key.C;
|
|
case KeyCode.D: return Key.D;
|
|
case KeyCode.E: return Key.E;
|
|
case KeyCode.F: return Key.F;
|
|
case KeyCode.G: return Key.G;
|
|
case KeyCode.H: return Key.H;
|
|
case KeyCode.I: return Key.I;
|
|
case KeyCode.J: return Key.J;
|
|
case KeyCode.K: return Key.K;
|
|
case KeyCode.L: return Key.L;
|
|
case KeyCode.M: return Key.M;
|
|
case KeyCode.N: return Key.N;
|
|
case KeyCode.O: return Key.O;
|
|
case KeyCode.P: return Key.P;
|
|
case KeyCode.Q: return Key.Q;
|
|
case KeyCode.R: return Key.R;
|
|
case KeyCode.S: return Key.S;
|
|
case KeyCode.T: return Key.T;
|
|
case KeyCode.U: return Key.U;
|
|
case KeyCode.V: return Key.V;
|
|
case KeyCode.W: return Key.W;
|
|
case KeyCode.X: return Key.X;
|
|
case KeyCode.Y: return Key.Y;
|
|
case KeyCode.Z: return Key.Z;
|
|
case KeyCode.LeftCurlyBracket: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Pipe: return unknownKey; // Conversion unknown.
|
|
case KeyCode.RightCurlyBracket: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Tilde: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Numlock: return Key.NumLock;
|
|
case KeyCode.CapsLock: return Key.CapsLock;
|
|
case KeyCode.ScrollLock: return Key.ScrollLock;
|
|
case KeyCode.RightShift: return Key.RightShift;
|
|
case KeyCode.LeftShift: return Key.LeftShift;
|
|
case KeyCode.RightControl: return Key.RightCtrl;
|
|
case KeyCode.LeftControl: return Key.LeftCtrl;
|
|
case KeyCode.RightAlt: return Key.RightAlt;
|
|
case KeyCode.LeftAlt: return Key.LeftAlt;
|
|
case KeyCode.LeftCommand: return Key.LeftCommand;
|
|
// case KeyCode.LeftApple: (same as LeftCommand)
|
|
case KeyCode.LeftWindows: return Key.LeftWindows;
|
|
case KeyCode.RightCommand: return Key.RightCommand;
|
|
// case KeyCode.RightApple: (same as RightCommand)
|
|
case KeyCode.RightWindows: return Key.RightWindows;
|
|
case KeyCode.AltGr: return Key.AltGr;
|
|
case KeyCode.Help: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Print: return Key.PrintScreen;
|
|
case KeyCode.SysReq: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Break: return unknownKey; // Conversion unknown.
|
|
case KeyCode.Menu: return Key.ContextMenu;
|
|
case KeyCode.Mouse0:
|
|
case KeyCode.Mouse1:
|
|
case KeyCode.Mouse2:
|
|
case KeyCode.Mouse3:
|
|
case KeyCode.Mouse4:
|
|
case KeyCode.Mouse5:
|
|
case KeyCode.Mouse6:
|
|
return mouseKey; // Not supported anymore.
|
|
|
|
// All other keys are joystick keys which do not
|
|
// exist anymore in the new input system.
|
|
default:
|
|
return joystickKey; // Not supported anymore.
|
|
}
|
|
}
|
|
#endif
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|