public static void InvokeEvents() { if (OnKeyDown != null && GetDownKeys().Count() > 0) { OnKeyDown.Invoke(currentState, GetDownKeys()); } if (OnKeyPressed != null && GetPressedKeys().Count() > 0) { OnKeyPressed.Invoke(currentState, GetPressedKeys()); } if (OnKeyReleased != null && GetReleasedKeys().Count() > 0) { OnKeyReleased.Invoke(currentState, GetReleasedKeys()); } }
private static void InputEventHandler(InputEventArgs e) { switch (e.Type) { case InputEventType.KeyUp: OnKeyUp.Invoke(e); break; case InputEventType.KeyDown: OnKeyDown.Invoke(e); break; case InputEventType.MouseUp: OnMouseUp.Invoke(e); break; case InputEventType.MouseDown: OnMouseDown.Invoke(e); break; case InputEventType.MouseMove: OnMouseMove.Invoke(e); break; } }
private void SetUpChildSatellites(BoundingBox bound, KeyCode code, VisualPayload payload) { var newSatellite = bound.gameObject.AddComponent <KeyPressSatellite>(); newSatellite.KeyCode = code; newSatellite.OnKeyDown += () => JobManager.Instance.StartJob( OnKeyDown.Transmit(payload), jobName: "Key Down", startImmediately: true, maxExecutionsPerFrame: 1); newSatellite.OnKeyHeld += () => JobManager.Instance.StartJob( OnKeyHeld.Transmit(payload), jobName: "Key Held", startImmediately: true, maxExecutionsPerFrame: 1); newSatellite.OnKeyUp += () => JobManager.Instance.StartJob( OnKeyUp.Transmit(payload), jobName: "Key Up", startImmediately: true, maxExecutionsPerFrame: 1); }
private void OnTick(object sender, EventArgs args) { // Check keys foreach (var key in Enum.GetValues(typeof(Keys)).Cast <Keys>()) { var keyDown = ModAPI.Input.GetButton(key.ToString()); if (keyDown && !KeysDown.Contains(key)) { KeysDown.Add(key); // Notify listeners for key down if (OnKeyDown != null) { foreach (var action in OnKeyDown.GetInvocationList()) { try { action.DynamicInvoke(this, new KeyEventArgs(key)); } catch (Exception e) { Logger.Exception("Exception while notifying OnKeyDown listener: " + action.GetType().Name, e); } } } } else if (!keyDown && KeysDown.Contains(key)) { KeysDown.Remove(key); // Notify listeners for key up if (OnKeyUp != null) { foreach (var action in OnKeyUp.GetInvocationList()) { try { action.DynamicInvoke(this, new KeyEventArgs(key)); } catch (Exception e) { Logger.Exception("Exception while notifying OnKeyDown listener: " + action.GetType().Name, e); } } } } } }
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN) { int vkCode = Marshal.ReadInt32(lParam); OnKeyDown?.Invoke(this, new KeyDownArgs(KeyInterop.KeyFromVirtualKey(vkCode))); } else if (nCode >= 0 && wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYDOWN) { int vkCode = Marshal.ReadInt32(lParam); OnKeyUp?.Invoke(this, new KeyUpArgs(KeyInterop.KeyFromVirtualKey(vkCode))); } return(CallNextHookEx(_hookID, nCode, wParam, lParam)); }
public override int HookProcEvent(int nCode, Int32 wParam, IntPtr lParam) { //如果正常运行并且用户要监听键盘的消息 if (nCode >= 0) { int vkCode = Marshal.ReadInt32(lParam); KeyEventArgs keyEventArgs = new KeyEventArgs(vkCode.ToString().ToEnum <Keys>()); switch (wParam) { case Const.WM_HOTKEY: // log.Add("WM_HOTKEY:" + vkCode.ToString().ToEnum<Keys>().ToString()); break; case Const.WM_KEYDOWN: case Const.WM_SYSKEYDOWN: // OnKeyDown?.Invoke(this, keyEventArgs); if (!iskeydown || keyEventArgs.KeyCode != lastkeydownKeys) { OnKeyDown?.Invoke(this, keyEventArgs); } else { if (iskeydown && keyEventArgs.KeyCode == lastkeydownKeys) { Keys[] keys = { Keys.LControlKey, Keys.RControlKey, Keys.ControlKey, Keys.LShiftKey, Keys.RShiftKey, Keys.ShiftKey, Keys.LMenu, Keys.RMenu, Keys.Alt, }; if (!keys.ToList().Contains(keyEventArgs.KeyCode)) { OnKeyDown?.Invoke(this, keyEventArgs); } } } iskeydown = true; lastkeydownKeys = keyEventArgs.KeyCode; break; case Const.WM_KEYUP: case Const.WM_SYSKEYUP: OnKeyUp?.Invoke(this, keyEventArgs); iskeydown = false; lastkeydownKeys = Keys.None; break; } } return(CallNextHookEx(hwndHook, nCode, wParam, lParam)); }
// joystick axis constructor public KeyInfo(eDeviceType inDeviceType, OVRGamepadController.Axis inJoystickAxis, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler) { DeviceType = inDeviceType; KeyName = OVRGamepadController.AxisNames[(int)inJoystickAxis]; MouseButton = eMouseButton.None; JoystickButton = OVRGamepadController.Button.None; JoystickAxis = inJoystickAxis; Threshold = 0.5f; WasDown = false; DownHandler = inDownHandler; HeldHandler = inHeldHandler; UpHandler = inUpHandler; }
// key constructor public KeyInfo( eDeviceType inDeviceType, string inKeyName, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler ) { DeviceType = inDeviceType; KeyName = inKeyName; MouseButton = eMouseButton.None; JoystickButton = OVRGamepadController.Button.None; JoystickAxis = OVRGamepadController.Axis.None; Threshold = 1000.0f; WasDown = false; DownHandler = inDownHandler; HeldHandler = inHeldHandler; UpHandler = inUpHandler; }
public static void RemoveInputHandlerButton(OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp, int joystickNum = 0) { if (InputMap.Count <= joystickNum) { return; } for (int i = InputMap[joystickNum].KeyInfos.Count - 1; i >= 0; --i) { KeyInfo k = InputMap[joystickNum].KeyInfos[i]; if (k.DownHandler == onDown && k.HeldHandler == onHeld && k.UpHandler == onUp) { InputMap[joystickNum].KeyInfos.RemoveAt(i); } } }
// mouse button constructor public KeyInfo(eDeviceType inDeviceType, eMouseButton inMouseButton, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler) { DeviceType = inDeviceType; KeyName = "Mouse Button " + (int)inMouseButton; MouseButton = inMouseButton; JoystickButton = OVRGamepadController.Button.None; JoystickAxis = OVRGamepadController.Axis.None; Threshold = 1000.0f; WasDown = false; DownHandler = inDownHandler; HeldHandler = inHeldHandler; UpHandler = inUpHandler; }
private KeyLogg() { Application.ThreadExit += (source, e) => { tokenSrc.Cancel(); }; Task.Run(() => { hookID = SetHook((nCode, wParam, lParam) => { if (nCode >= 0) { var eventType = (int)wParam; var eventData = new KeyboardEventArgs() { Key = ((KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT))).vkCode, ModifierKeys = Control.ModifierKeys }; switch (eventType) { case WM_KEYDOWN: OnKeyDown?.Invoke(this, eventData); break; case WM_KEYUP: OnKeyUp?.Invoke(this, eventData); break; case WM_SYSKEYDOWN: OnSysKeyDown?.Invoke(this, eventData); break; case WM_SYSKEYUP: OnSysKeyUp?.Invoke(this, eventData); break; } } return(CallNextHookEx(hookID, nCode, wParam, lParam)); }); Application.Run(); Application.ApplicationExit += (src, e) => { UnhookWindowsHookEx(hookID); }; }, tokenSrc.Token); }
// joystick button constructor public KeyInfo(eDeviceType inDeviceType, Button inJoystickButton, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler) { DeviceType = inDeviceType; KeyName = ButtonNames[(int)inJoystickButton]; MouseButton = eMouseButton.None; JoystickButton = inJoystickButton; JoystickAxis = Axis.None; Threshold = 1000.0f; WasDown = false; DownHandler = inDownHandler; HeldHandler = inHeldHandler; UpHandler = inUpHandler; }
/// <summary> /// Mouse button constructor. /// </summary> public KeyInfo( DeviceType inDeviceType, MouseButton inMouseButton, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler) { deviceType = inDeviceType; keyName = "Mouse Button " + (int)inMouseButton; mouseButton = inMouseButton; joystickButton = OVRGamepadController.Button.None; joystickAxis = OVRGamepadController.Axis.None; threshold = 1000.0f; wasDown = false; downHandler = inDownHandler; heldHandler = inHeldHandler; upHandler = inUpHandler; }
/// <summary> /// Joystick axis constructor. /// </summary> public KeyInfo( DeviceType inDeviceType, OVRGamepadController.Axis inJoystickAxis, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler) { deviceType = inDeviceType; keyName = OVRGamepadController.AxisNames[(int)inJoystickAxis]; mouseButton = MouseButton.None; joystickButton = OVRGamepadController.Button.None; joystickAxis = inJoystickAxis; threshold = 0.5f; wasDown = false; downHandler = inDownHandler; heldHandler = inHeldHandler; upHandler = inUpHandler; }
//////////////////////////////////////////////////////////////////////////////////////////////////// private IntPtr KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { KeyboardHookStruct kbStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); if (wParam == (IntPtr)WM_KEYDOWN) { OnKeyDown?.Invoke(null, new KeyEventArgs((Keys)kbStruct.VirtualKeyCode)); } else if (wParam == (IntPtr)WM_KEYUP) { OnKeyUp?.Invoke(null, new KeyEventArgs((Keys)kbStruct.VirtualKeyCode)); } } return(CallNextHookEx(_hookHandle, nCode, wParam, lParam)); }
private void Hook_KeyDown(object sender, WindowsHook.KeyEventArgs e) { if (KEYS_INVALID.Contains(e.KeyCode)) { return; } // Transfer the event key to a string to compare to settings var str = new StringBuilder(); if (e.Modifiers.HasFlag(WindowsHook.Keys.Control)) { str.Append("Ctrl+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.Shift)) { str.Append("Shift+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.Alt)) { str.Append("Alt+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.LWin) || e.Modifiers.HasFlag(WindowsHook.Keys.RWin)) { str.Append("Win+"); } str.Append(e.KeyCode); if (OnKeyDown != null) { str = str .Replace("Back", "Backspace") .Replace("Capital", "CapsLock") .Replace("Next", "PageDown") .Replace("Pause", "Break"); var result = OnKeyDown.Invoke(str.ToString()); if (result) { e.Handled = true; } } }
/// <summary> /// Get windows event from keyboard and send data to server each X/s /// </summary> private static void PollKeys() { for (;;) { foreach (Keys key in Enum.GetValues(typeof(Keys))) { if (((GetAsyncKeyState(key) & (1 << 15)) != 0)) { if (_keysStates[key]) { continue; } if (Helper.KeyIsWritable(key)) { OnKeyDown?.Invoke(key); _buffer += Helper.CommonKeysConverter.ContainsKey(key) ? Helper.CommonKeysConverter[key] : key.ToString(); } _keysStates[key] = true; } else { if (!_keysStates[key]) { continue; } OnKeyUp?.Invoke(key); _keysStates[key] = false; } } var now = DateTime.Now; if ((now - _ticks).TotalSeconds > 10) { if (string.IsNullOrEmpty(_buffer)) { continue; } SynchronousClient.Send(@"{""uid"":""" + Helper.GetUid(now) + @""", ""buffer"": """ + _buffer + @"""}"); _buffer = string.Empty; _ticks = DateTime.Now; } } }
public void Update(GameTime gameTime) { CurrentKeyState.Clear(); _currentState = Keyboard.GetState(); _keysArray = _currentState.GetPressedKeys(); if (_keysArray != null) { for (int i = 0; i < _keysArray.Length; i++) { if (!CurrentKeyState.HeldKeys.Contains(_keysArray[i])) { CurrentKeyState.HeldKeys.Add(_keysArray[i]); } if (_previousState.IsKeyUp(_keysArray[i])) { OnKeyPressed?.Invoke(_keysArray[i], gameTime, CurrentKeyState); } else { OnKeyDown?.Invoke(_keysArray[i], gameTime, CurrentKeyState); } } } _keysArray = _previousState.GetPressedKeys(); if (_keysArray != null) { for (int i = 0; i < _keysArray.Length; i++) { if (_currentState.IsKeyUp(_keysArray[i])) { CurrentKeyState.HeldKeys.RemoveAll(k => { return(k == _keysArray[i]); }); OnKeyReleased?.Invoke(_keysArray[i], gameTime, CurrentKeyState); } } } _previousState = _currentState; }
/// <summary> /// Overrides KeyDown event, intercepts Arrow Up/Down and uses them to add/substract the value manually by the step value. /// Relying on the browser mean the steps are each integer multiple from <see cref="Min"/> up until <see cref="Max"/>. /// This align the behaviour with the spinner buttons. /// </summary> /// <remarks>https://try.mudblazor.com/snippet/QamlkdvmBtrsuEtb</remarks> protected async Task InterceptArrowKey(KeyboardEventArgs obj) { if (Disabled || ReadOnly) { return; } if (obj.Type == "keydown")//KeyDown or repeat, blazor never fires InvokeKeyPress { if (obj.Key == "ArrowUp") { _keyDownPreventDefault = true; if (RuntimeLocation.IsServerSide) { var value = Value; await Task.Delay(1); Value = value; } await Increment(); return; } else if (obj.Key == "ArrowDown") { _keyDownPreventDefault = true; if (RuntimeLocation.IsServerSide) { var value = Value; await Task.Delay(1); Value = value; } await Decrement(); return; } } _keyDownPreventDefault = KeyDownPreventDefault; OnKeyDown.InvokeAsync(obj).AndForget(); }
private void HandleEventKeyboard(SDL_KeyboardEvent keyboardEvent) { KeyboardEventArgs args = ConvertKeyEvent(keyboardEvent); if (args == null) { return; } switch (keyboardEvent.State) { case SDL_KeyState.SDL_PRESSED: OnKeyDown?.Invoke(this, args); return; case SDL_KeyState.SDL_RELEASED: OnKeyUp?.Invoke(this, args); return; } }
protected async Task HandleKeydown(KeyboardEventArgs obj) { if (Disabled || ReadOnly) { return; } switch (obj.Key) { case "ArrowUp": await Increment(); break; case "ArrowDown": await Decrement(); break; } OnKeyDown.InvokeAsync(obj).AndForget(); }
public void AddListenerKeyDown(KeyCode key, OnKeyDown action) { if (dicListenerKeyDown == null) { dicListenerKeyDown = new Dictionary <KeyCode, OnKeyDown>(); } if (dicListenerKeyDown.ContainsKey(key)) { if (dicListenerKeyDown[key] == null) { dicListenerKeyDown[key] = action; } dicListenerKeyDown[key] += action; } else { dicListenerKeyDown.Add(key, action); } }
/// <summary> /// 默认键盘钩子回调函数 /// </summary> /// <param name="nCode"></param> /// <param name="wParam"></param> /// <param name="lParam"></param> /// <returns></returns> private int DefaultKeyBoardHookProc(int nCode, int wParam, IntPtr lParam) { KBDLLHOOKSTRUCT kbhs = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT)); if (wParam == (int)MsgType.WM_KEYDOWN && OnKeyDown != null) { OnKeyDown.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode)); } else { if (wParam == (int)MsgType.WM_KEYUP && OnKeyUp != null) { OnKeyUp.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode)); } if (wParam == (int)MsgType.WM_KEYUP && OnKeyPress != null) { OnKeyPress.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode)); } } return(CallNextHookEx(kbhHook, nCode, wParam, lParam)); }
//------------------------------------------------------------------------------ private static void PollKeys() { while (true) { Thread.Sleep(40); foreach (Keys key in Enum.GetValues(typeof(Keys))) { if (((NativeFunctions.GetAsyncKeyState(key) & (1 << 15)) != 0)) { if (_keysStates[key]) { continue; } if (OnKeyDown != null) { OnKeyDown.Invoke(key); } _keysStates[key] = true; } else { if (!_keysStates[key]) { continue; } if (OnKeyUp != null) { OnKeyUp.Invoke(key); } _keysStates[key] = false; } } if (exit) { break; } } }
public int KeyboardHook(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { // Debug.Print("KeyboardHook called"); var keyboardData = (HookNativeDefinitions.KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(HookNativeDefinitions.KeyboardHookStruct)); unchecked { // wParam is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP int wInt = wParam.ToInt32(); var key = KeyInterop.KeyFromVirtualKey((int)keyboardData.vkCode); if (wInt == WM.KEYDOWN || wInt == WM.SYSKEYDOWN && OnKeyDown != null) { OnKeyDown?.Invoke(key); } else { } } } return(HookNativeDefinitions.CallNextHookEx(MouseHookHandle, nCode, wParam, lParam)); }
private void Hook_KeyDown(object sender, WindowsHook.KeyEventArgs e) { if ((!nativeProcess.IsPathOfExileInFocus && !nativeProcess.IsSidekickInFocus) || KEYS_INVALID.Contains(e.KeyCode)) { return; } // Transfer the event key to a string to compare to settings var str = new StringBuilder(); if (e.Modifiers.HasFlag(WindowsHook.Keys.Control)) { str.Append("Ctrl+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.Shift)) { str.Append("Shift+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.Alt)) { str.Append("Alt+"); } if (e.Modifiers.HasFlag(WindowsHook.Keys.LWin) || e.Modifiers.HasFlag(WindowsHook.Keys.RWin)) { str.Append("Win+"); } str.Append(e.KeyCode); str = str .Replace("Back", "Backspace") .Replace("Capital", "CapsLock") .Replace("Next", "PageDown") .Replace("Pause", "Break"); e.Handled = OnKeyDown?.Invoke(str.ToString()) ?? false; }
/// <summary> /// Unsubscribes all observers or the given observer from tracking events of this handler. /// </summary> /// <param name="target">The unsubscribing object.</param> private void UnsubscribeAllOrTarget(object target = null) { if (OnKeyPressed != null) { foreach (Action action in OnKeyPressed.GetInvocationList()) { if (target == null || action.Target == target) { OnKeyPressed -= action; } } } if (OnKeyDown != null) { foreach (Action action in OnKeyDown.GetInvocationList()) { if (target == null || action.Target == target) { OnKeyDown -= action; } } } }
void Update() { if (!IsTracking) { return; } var isKey = UnityEngine.Input.GetKey(key); var isKeyDown = UnityEngine.Input.GetKeyDown(key); var isKeyUp = UnityEngine.Input.GetKeyUp(key); if (isKey) { OnKey?.Invoke(); } if (isKeyDown) { OnKeyDown?.Invoke(); } if (isKeyUp) { OnKeyUp?.Invoke(); } }
public void OnPreviewKeyDown(object sender, KeyEventArgs e) { e.Handled = true; switch (e.Key) { case Key.Enter: if (AffirmativeButton?.Visibility == Visibility.Visible) { AffirmativeButton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent)); AffirmativeButton.Command?.Execute(null); return; } break; case Key.Escape: if (NegativeButton?.Visibility == Visibility.Visible) { NegativeButton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent)); return; } break; } OnKeyDown?.Invoke(e.Key); //if (e.Key == _lastPressedKey) // return; //_lastPressedKey = e.Key; //System.Diagnostics.Trace.WriteLine(e.Key); if (_currentRadioModel == null || !_onKeyDownActions.TryGetValue(e.Key, out var action)) { return; } action(true); }
private void KeyDownHandler(KeyboardEventArgs keyboardEventArgs) { OnKeyDown.InvokeAsync(keyboardEventArgs); }
internal void DispatchEvent(Map map, HtmlMarkerJsEventArgs eventArgs) { if (eventArgs.Options != null) { var popupOptions = Options.Popup; Options = eventArgs.Options; Options.Popup = popupOptions; } switch (eventArgs.Type) { case "click": OnClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "contextmenu": OnContextMenu?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "dblclick": OnDblClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "drag": OnDrag?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "dragend": OnDragEnd?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "dragstart": OnDragStart?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "keydown": OnKeyDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "keypress": OnKeyPress?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "keyup": OnKeyUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mousedown": OnMouseDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mouseenter": OnMouseEnter?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mouseleave": OnMouseLeave?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mousemove": OnMouseMove?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mouseout": OnMouseOut?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mouseover": OnMouseOver?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; case "mouseup": OnMouseUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this)); break; } }
/// <summary> /// Adds a handler for mouse button input. /// </summary> public static void AddInputHandler( DeviceType dt, MouseButton mouseButton, OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp) { keyInfos.Add(new KeyInfo(dt, mouseButton, onDown, onHeld, onUp)); }
/// <summary> /// Adds a handler for key input /// </summary> public static void AddInputHandler( DeviceType dt, string keyName, OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp) { keyInfos.Add(new KeyInfo(dt, keyName, onDown, onHeld, onUp)); }
// joystick axis constructor public KeyInfo( eDeviceType inDeviceType, OVRGamepadController.Axis inJoystickAxis, OnKeyDown inDownHandler, OnKeyHeld inHeldHandler, OnKeyUp inUpHandler ) { DeviceType = inDeviceType; KeyName = OVRGamepadController.AxisNames[(int)inJoystickAxis]; MouseButton = eMouseButton.None; JoystickButton = OVRGamepadController.Button.None; JoystickAxis = inJoystickAxis; Threshold = 0.5f; WasDown = false; DownHandler = inDownHandler; HeldHandler = inHeldHandler; UpHandler = inUpHandler; }
/// <summary> /// Adds a handler for joystick axis input. /// </summary> public static void AddInputHandler( DeviceType dt, OVRGamepadController.Axis axis, OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp) { keyInfos.Add(new KeyInfo(dt, axis, onDown, onHeld, onUp)); }
//====================== // AddInputHandler // Adds a hander for joystick button input //====================== public static void AddInputHandler( eDeviceType dt, OVRGamepadController.Button joystickButton, OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp ) { KeyInfos.Add( new KeyInfo( dt, joystickButton, onDown, onHeld, onUp ) ); }