Stride.Input Namespace
Classes
| 
                               Event for an axis changing state on a device  | 
                      ||
| 
                               Event for a button changing state on a device  | 
                      ||
| 
                               An event used when a device was changed  | 
                      ||
| 
                               An event to describe a change in a game controller axis state  | 
                      ||
| 
                               Provides information about a gamepad axis  | 
                      ||
| 
                               An event to describe a change in game controller button state  | 
                      ||
| 
                               Provides information about a gamepad button  | 
                      ||
| 
                               Base class for gamepads, contains common functionality for gamepad devices  | 
                      ||
| 
                               Provides easier ways to set vibration levels on a controller, rather than setting 4 motors  | 
                      ||
| 
                               An event to describe a change in game controller direction state  | 
                      ||
| 
                               Provides information about a gamepad direction input  | 
                      ||
| 
                               Provides information about an object exposed by a gamepad  | 
                      ||
| 
                               Provides some useful functions relating to game controllers  | 
                      ||
| 
                               An event to describe a change in a gamepad axis  | 
                      ||
| 
                               An event to describe a change in gamepad button state  | 
                      ||
| 
                               Provides easier ways to set vibration levels on a controller, rather than setting 4 motors  | 
                      ||
| 
                               A IGamePadDevice from a IGameControllerDevice using a GamePadLayout to create a mapping between the two  | 
                      ||
| 
                               Event for when a IGamePadDevice's index changed  | 
                      ||
| 
                               Provides a IGameControllerDevice to IGamePadDevice mapping  | 
                      ||
| 
                               A gamepad layout for a DualShock4 controller  | 
                      ||
| 
                               Keeps track of GamePadLayout  | 
                      ||
| 
                               Layout for XInput devices so that they can be used by SDL or other systems that do not have the XInput API but do support joysticks in some other way  | 
                      ||
| 
                               This represents the base class for all gesture configuration.  | 
                      ||
| 
                               Configuration class for the Composite gesture.  | 
                      ||
| 
                               Configuration class for the Drag gesture.  | 
                      ||
| 
                               Configuration class for the Flick gesture.  | 
                      ||
| 
                               Configuration class the Long Press gestures.  | 
                      ||
| 
                               Configuration class for the Tap gesture.  | 
                      ||
| 
                               Base class for the gesture events.  | 
                      ||
| 
                               Event class for the Composite gesture.  | 
                      ||
| 
                               Event class for the Drag gesture.  | 
                      ||
| 
                               Event class for the Flick gesture.  | 
                      ||
| 
                               Event class for the LongPress gesture.  | 
                      ||
| 
                               Event class for the Tap gesture.  | 
                      ||
| 
                               Event class for the Drag gesture.  | 
                      ||
| 
                               Utilities for input devices  | 
                      ||
| 
                               An event that was generated from an IInputDevice  | 
                      ||
| 
                               Pools input events of a given type  | 
                      ||
| 
                               Manages collecting input from connected input device in the form of IInputDevice objects. Also provides some convenience functions for most commonly used devices  | 
                      ||
| 
                               Arguments for input pre update event  | 
                      ||
| 
                               Base class for input sources, implements common parts of the IInputSource interface and keeps track of registered devices through RegisterDevice(IInputDevice) and UnregisterDevice(IInputDevice)  | 
                      ||
| 
                               Given a GameContext creates the corresponding IInputSource for the platform specific window.  | 
                      ||
| 
                               Provides a virtual mouse and keyboard that generate input events like a normal mouse/keyboard when any of the functions (Simulate...) are called  | 
                      ||
| 
                               Base class for keyboard devices  | 
                      ||
| 
                               Event for a keyboard button changing state  | 
                      ||
| 
                               Describes a button on a mouse changing state  | 
                      ||
| 
                               Base class for mouse devices, implements some common functionality of IMouseDevice, inherits from PointerDeviceBase  | 
                      ||
| 
                               An extension to PointerDeviceState that handle mouse input and translates it to pointer input  | 
                      ||
| 
                               Event for a mouse wheel being used  | 
                      ||
| 
                               Base class for pointer devices  | 
                      ||
| 
                               Contains logic to generate pointer events and store the resulting state  | 
                      ||
| 
                               Some additional data kept on top of PointerPoint for the purpose of generating PointerEvent  | 
                      ||
| 
                               A pointer event.  | 
                      ||
| 
                               Represents a unique pointer that is or was on the screen and information about it  | 
                      ||
| 
                               Simulation of PointerEvents  | 
                      ||
| 
                               An event for when the size of a pointer surface changed  | 
                      ||
| 
                               Input event used for text input and IME related events  | 
                      ||
| 
                               Describes a virtual button (a key from a keyboard, a mouse button, an axis of a joystick...etc.).  | 
                      ||
| 
                               GamePad virtual button.  | 
                      ||
| 
                               Keyboard virtual button.  | 
                      ||
| 
                               Mouse virtual button.  | 
                      ||
| 
                               Mouse virtual button.  | 
                      ||
| 
                               Describes a binding between a name and a IVirtualButton.  | 
                      ||
| 
                               Describes the configuration composed by a collection of VirtualButtonBinding.  | 
                      ||
| 
                               A collection of VirtualButtonConfig.  | 
                      ||
| 
                               Describes a IVirtualButton using the sum of a negative and positive button.  | 
                      
Structs
| 
                               Represents a direction or neutral position  | 
                      ||
| 
                               Describes the state of a typical gamepad.  | 
                      ||
| 
                               Simplified event data used to generate the full events when Update(List<InputEvent>) gets called  | 
                      
Interfaces
| 
                               This class represents a sensor of type Accelerometer. It measures the acceleration forces (including gravity) applying on the device.  | 
                      ||
| 
                               This class represents a sensor of type compass. It measures the angle between the device and the north.  | 
                      ||
| 
                               This interface is used for interacting with game controller devices.  | 
                      ||
| 
                               A gamepad is a game controller that has a fixed button mapping, stored in State  | 
                      ||
| 
                               This class represents a sensor of type Gravity. It measures the gravity force applying on the device.  | 
                      ||
| 
                               This class represents a sensor of type Gyroscope. It measures the rotation speed of device along the x/y/z axis.  | 
                      ||
| 
                               Does not listen to any event but is used to pass around a type that might potentially listen for input events  | 
                      ||
| 
                               Interface for classes that want to listen to input event of a certain type  | 
                      ||
| 
                               An abstraction for a platform specific mechanism that provides input in the form of one of multiple IInputDevice(s). An input source is responsible for cleaning up it's own devices at cleanup  | 
                      ||
| 
                               A keyboard device  | 
                      ||
| 
                               Represents functionality specific to mouse input such as buttons, wheels, mouse locking and setting cursor position  | 
                      ||
| 
                               This class represents a sensor of type Orientation. It measures the orientation of device in the real world.  | 
                      ||
| 
                               Provides an interface for interacting with pointer devices, this can be a mouse, pen, touch screen, etc.  | 
                      ||
| 
                               Interface for a sensor device, use more specific interfaces to retrieve sensor data  | 
                      ||
| 
                               A device such as a keyboard that supports text input. This can be a windows keyboard with IME support or a touch keyboard on a smartphone device  | 
                      ||
| 
                               This class represents a sensor of type user acceleration. It measures the acceleration applied by the user (no gravity) onto the device.  | 
                      ||
| 
                               Interface IVirtualButton  | 
                      
Enums
| 
                               The types of gamepad buttons  | 
                      ||
| 
                               Axis for gamepad returned by GamePadState.  | 
                      ||
| 
                               Buttons for gamepad returned by GamePadState.  | 
                      ||
| 
                               Gesture possible shapes.  | 
                      ||
| 
                               The different possible states of a gestures.  | 
                      ||
| 
                               List all the available type of Gestures.  | 
                      ||
| 
                               Enumeration for keys.  | 
                      ||
| 
                               Mouse axes  | 
                      ||
| 
                               Mouse buttons.  | 
                      ||
| 
                               State of a pointer event.  | 
                      ||
| 
                               Type of a VirtualButton.  |