RELEASES.md

Release Notes

Version 0.16.0 (Unreleased)

Bugs (0.16.0)

• fixed the bug where the values of buttonlike ActionStates cann't be retrieved
  • now you can use button_value function of ActionState to get the value of a buttonlike action
  • added value and friends as the fields of action_data::ButtonData
  • GamepadButton and GamepadButtonType now get values from Axis<GamepadButton>
  • VirtualAxis, VirtualDPad, and VirtualDPad3D now report axis values based on the values of the constitute buttons
  • added value field to ActionDiff::Pressed
• added missing deserializer function for MouseButton

Usability (0.16.0)

• made virtual axial controls more flexible, accepting any kind of Buttonlike
  • removed KeyboardVirtualAxis and GamepadVirtualAxis in favor of VirtualAxis
  • removed KeyboardVirtualDPad and GamepadVirtualDPad in favor of VirtualDPad
  • removed KeyboardVirtualDPad3D in favor of VirtualDPad3D
• added threshold value for GamepadControlDirection, MouseMoveDirection, and MouseScrollDirection to be considered pressed.
• added ability to filter entities to generate action diffs for:
  • added new generate_action_diffs_filtered<A, F> system, which accepts a QueryFilter, so that only entities matching QueryFilter F (and with ActionState<A>) generate action diffs
  • added new summarize_filtered<F> function for SummarizedActionState<A> (alongside the original summarize).

Version 0.15.1

Enhancements (0.15.1)

• added TripleAxislike trait for inputs that track all X, Y, and Z axes.
  • added KeyboardVirtualDPad3D that consists of six KeyCodes to represent a triple-axis-like input.
  • added TripleAxislikeChord that groups a Buttonlike and a TripleAxislike together.
  • added related variants such as:
    • InputControlType::TripleAxis
    • ActionDiff::TripleAxisChanged

Usability (0.15.1)

InputMap reflection

• Reflect Component and Resource, which enables accessing the data in the type registry

Actionlike macro improvements

• added #[actionlike] for actions to set their input kinds, either on an enum or on its individual variants.

ActionState reflection

• Reflect Component and Resource, which enables accessing the data in the type registry

Input Processors

• allowed creating DualAxisBounds, DualAxisExclusion, and DualAxisDeadZone from their struct definitions directly.
• added at_least and at_most methods for those implementing WithAxisProcessorExt trait.
• added at_least, at_least_only_x, at_least_only_y, at_most, at_most_only_x, and at_most_only_y methods for those implementing WithDualAxisProcessorExt trait.
• added only_positive and only_negative builders for AxisDeadZone and AxisExclusion.
  • added corresponding extension methods for those implementing WithAxisProcessorExt trait.
• added only_positive, only_positive_x, only_positive_y, only_negative, only_negative_x, and only_negative_y builders for DualAxisDeadZone and DualAxisExclusion.
  • added corresponding extension methods for those implementing WithDualAxisProcessorExt trait.

ActionDiffEvent

• Implement MapEntities, which lets networking crates translate owner entity IDs between ECS worlds

Bugs (0.15.1)

• fixed the broken deserialization of inputs and InputMaps
• InputMap::get_pressed and siblings now check if the action kind is buttonlike before checking if they are pressed or released, avoiding a debug-mode panic
• InputMap::merge is now compatible with all input kinds, previously limited to buttons

Version 0.15.0

Enhancements (0.15)

Trait-based input design

• added the UserInput trait, which can be divided into three subtraits: Buttonlike, Axislike and DualAxislike
  • the InputControlKind for each action can be set via the new Actionlike::input_control_kind method. The derive will assume that all actions are buttonlike.
  • many methods such as get on InputMap and ActionState have been split into three variants, one for each kind of input
• there is now a clear division between buttonlike, axislike and dualaxislike data
  • each action in an Actionlike enum now has a specific InputControlKind, mapping it to one of these three categories
  • if you are storing non-buttonlike actions (e.g. movement) inside of your Actionlike enum, you must manually implement the trait
  • pressed / released state can only be accessed for buttonlike data: invalid requests will always return released
  • f32 values can only be accessed for axislike data: invalid requests will always return 0.0
  • ActionData has been refactored, and now stores common data and input-kind specific data separately
  • 2-dimensional DualAxisData can only be accessed for dualaxislike data: invalid requests will always return (0.0, 0.0)
  • Axislike inputs can no longer be inserted directly into an InputMap: instead, use the insert_axis method
  • Axislike inputs can no longer be inserted directly into an InputMap: instead, use the insert_dual_axis method
• InputStreams has been removed in favor of an extensible CentralInputStore type, which you can add your own raw input kinds to
• RawInputs has been removed to ensure that clashes for new raw input kinds can be handled correctly
• each of the built-in input methods (keyboard, mouse, gamepad) is now controlled by its own feature flag
  • disable default-features to avoid paying the runtime and compile time costs for input kinds your project doesn't care about
  • the bevy_gilrs feature of bevy is now enabled via the gamepad feature

More inputs

• added UserInput impls for gamepad input events:
  • implemented UserInput for Bevy’s GamepadAxisType-related inputs.
    • GamepadStick: DualAxislike, continuous or discrete movement events of the left or right gamepad stick along both X and Y axes.
    • GamepadControlAxis: Axislike, Continuous or discrete movement events of a GamepadAxisType.
    • GamepadControlDirection: Buttonlike, Discrete movement direction events of a GamepadAxisType, treated as a button press.
  • implemented UserInput for Bevy’s GamepadButtonType directly.
  • added GamepadVirtualAxis, which implements Axislike, similar to the old UserInput::VirtualAxis using two GamepadButtonTypes.
  • added GamepadVirtualDPad, which implements DualAxislike, similar to the old UserInput::VirtualDPad using four GamepadButtonTypes.
• added UserInput impls for keyboard inputs:
  • implemented Buttonlike for KeyCode and ModifierKey
  • implemented Buttonlike for ModifierKey.
  • added KeyboardVirtualAxis, which implements Axislike, similar to the old UserInput::VirtualAxis using two KeyCodes.
  • added KeyboardVirtualDPad which implements DualAxislike, similar to the old UserInput::VirtualDPad using four KeyCodes.
• added UserInput impls for mouse inputs:
  • implemented UserInput for movement-related inputs.
    • MouseMove: DualAxislike, continuous or discrete movement events of the mouse both X and Y axes.
    • MouseMoveAxis: Axislike, continuous or discrete movement events of the mouse on an axis, similar to the old SingleAxis::mouse_motion_*.
    • MouseMoveDirection: Buttonlike, discrete movement direction events of the mouse on an axis, similar to the old MouseMotionDirection.
  • implemented UserInput for wheel-related inputs.
    • MouseScroll: DualAxislike, continuous or discrete movement events of the mouse wheel both X and Y axes.
    • MouseScrollAxis: Axislike, continuous or discrete movement events of the mouse wheel on an axis, similar to the old SingleAxis::mouse_wheel_*.
    • MouseScrollDirection: ButtonLike, discrete movement direction events of the mouse wheel on an axis, similar to the old MouseWheelDirection.
• added ButtonlikeChord, AxislikeChord and DualAxislikeChord for combining multiple inputs, similar to the old UserInput::Chord.

Input Processors

Input processors allow you to create custom logic for axis-like input manipulation.

• added processor enums:
  • AxisProcessor: Handles single-axis values.
  • DualAxisProcessor: Handles dual-axis values.
• added processor traits for defining custom processors:
  • CustomAxisProcessor: Handles single-axis values.
  • CustomDualAxisProcessor: Handles dual-axis values.
  • added App extensions for registration of custom processors:
    • register_axis_processor for CustomAxisProcessor.
    • register_dual_axis_processor for CustomDualAxisProcessor.
• added built-in processors (variants of processor enums and Into<Processor> implementors):
  • Digital Conversion: Discretizes values, returning -1.0. 0.0 or 1.0:
    • AxisProcessor::Digital: Single-axis digital conversion.
    • DualAxisProcessor::Digital: Dual-axis digital conversion.
  • Inversion: Reverses control (positive becomes negative, etc.)
    • AxisProcessor::Inverted: Single-axis inversion.
    • DualAxisInverted: Dual-axis inversion, implemented Into<DualAxisProcessor>.
  • Sensitivity: Adjusts control responsiveness (doubling, halving, etc.).
    • AxisProcessor::Sensitivity: Single-axis scaling.
    • DualAxisSensitivity: Dual-axis scaling, implemented Into<DualAxisProcessor>.
  • Value Bounds: Define the boundaries for constraining input values.
    • AxisBounds: Restricts single-axis values to a range, implemented Into<AxisProcessor> and Into<DualAxisProcessor>.
    • DualAxisBounds: Restricts single-axis values to a range along each axis, implemented Into<DualAxisProcessor>.
    • CircleBounds: Limits dual-axis values to a maximum magnitude, implemented Into<DualAxisProcessor>.
  • Deadzones: Ignores near-zero values, treating them as zero.
    • Unscaled versions:
      • AxisExclusion: Excludes small single-axis values, implemented Into<AxisProcessor> and Into<DualAxisProcessor>.
      • DualAxisExclusion: Excludes small dual-axis values along each axis, implemented Into<DualAxisProcessor>.
      • CircleExclusion: Excludes dual-axis values below a specified magnitude threshold, implemented Into<DualAxisProcessor>.
    • Scaled versions:
      • AxisDeadZone: Normalizes single-axis values based on AxisExclusion and AxisBounds::default, implemented Into<AxisProcessor> and Into<DualAxisProcessor>.
      • DualAxisDeadZone: Normalizes dual-axis values based on DualAxisExclusion and DualAxisBounds::default, implemented Into<DualAxisProcessor>.
      • CircleDeadZone: Normalizes dual-axis values based on CircleExclusion and CircleBounds::default, implemented Into<DualAxisProcessor>.
• implemented WithAxisProcessingPipelineExt to manage processors for SingleAxis and VirtualAxis, integrating the common processing configuration.
• implemented WithDualAxisProcessingPipelineExt to manage processors for DualAxis and VirtualDpad, integrating the common processing configuration.

Better disabling

• Actions can now be disabled at both the individual action and ActionState level
• Disabling actions now resets their value, exposed via the ActionState::reset method
• ActionState::release_all has been renamed to ActionState::reset_all and now resets the values of Axislike and DualAxislike actions
• the state of actions now continues to be updated while they are disabled. However, when checked, their value is always released / zero.
  • this ensures that holding down an action, disabling it and then re-enabling it does not trigger just-pressed
  • the values of disabled actions can be accessed by checking their ActionData directly

Usability (0.15)

InputMap

• added new fluent builders for creating a new InputMap<A> with short configurations:
  • fn with(mut self, action: A, input: impl UserInput).
  • fn with_one_to_many(mut self, action: A, inputs: impl IntoIterator<Item = impl UserInput>).
  • fn with_multiple(mut self, bindings: impl IntoIterator<Item = (A, impl UserInput)>) -> Self.
  • fn with_gamepad(mut self, gamepad: Gamepad) -> Self.
• added new iterators over InputMap<A>:
  • actions(&self) -> impl Iterator<Item = &A> for iterating over all registered actions.
  • bindings(&self) -> impl Iterator<Item = (&A, &dyn UserInput)> for iterating over all registered action-input bindings.

ActionState

• removed ToggleActions resource in favor of new methods on ActionState: disable_all, disable(action), enable_all, enable(action), and disabled(action).

Input mocking

• MockInput, RawInputs and MutableInputStreams have been removed in favor of methods on the Buttonlike, Axislike and DualAxislike traits
  • for example, rather than app.press_input(KeyCode::Space) call KeyCode::Space.press(app.world_mut())
• existing methods for quickly checking the value of buttons and axes have been moved to the FetchUserInput trait and retained for testing purposes

Bugs (0.15)

• fixed a bug where enabling a pressed action would read as just_pressed, and disabling a pressed action would read as just_released.
• inputs are now handled correctly in the FixedUpdate schedule! Previously, the ActionStates were only updated in the PreUpdate schedule, so you could have situations where an action was marked as just_pressed multiple times in a row (if the FixedUpdate schedule ran multiple times in a frame) or was missed entirely (if the FixedUpdate schedule ran 0 times in a frame).
• Mouse motion and mouse scroll are now computed more efficiently and reliably, through the use of the new AccumulatedMouseMovement and AccumulatedMouseScroll resources.
• the timing field of the ActionData is now disabled by default. Timing information will only be collected if the timing feature is enabled. It is disabled by default because most games don't require timing information. (how long a button was pressed for)

Tech debt (0.15)

• removed ActionStateDriver and update_action_state_from_interaction, which allowed actions to be pressed by bevy_ui buttons
  • this feature was not widely used and can be easily replicated externally
  • the core pattern is simply calling action_state.press(MyAction::Variant) in one of your systems
• removed the no_ui_priority feature. To get this behavior, now just turn off the default ui feature
• removed the orientation module, migrating to bevy_math::Rot2
  • use the types provided in bevy_math instead
• remove action consuming (and various consume / consumed methods) to reduce complexity and avoid confusing overlap with action disabling
  • write your own logic for cases where this was used: generally by working off of ActionDiff events that are consumed

Migration Guide (0.15)

• renamed InputMap::which_pressed method to process_actions to better reflect its current functionality for clarity.
• the old SingleAxis is now:
  • GamepadControlAxis for gamepad axes.
  • MouseMoveAxis::X and MouseMoveAxis::Y for continuous mouse movement.
  • MouseScrollAxis::X and MouseScrollAxis::Y for continuous mouse wheel movement.
• the old DualAxis is now:
  • GamepadStick for gamepad sticks.
  • MouseMove::default() for continuous mouse movement.
  • MouseScroll::default() for continuous mouse wheel movement.
• the old Modifier is now ModifierKey.
• the old MouseMotionDirection is now MouseMoveDirection.
• the old MouseWheelDirection is now MouseScrollDirection.
• the old UserInput::Chord is now InputChord.
• the old UserInput::VirtualAxis is now:
  • GamepadVirtualAxis for four gamepad buttons.
  • KeyboardVirtualAxis for four keys.
  • MouseMoveAxis::X.digital() and MouseMoveAxis::Y.digital() for discrete mouse movement.
  • MouseScrollAxis::X.digital() and MouseScrollAxis::Y.digital() for discrete mouse wheel movement.
• the old UserInput::VirtualDPad is now:
  • GamepadVirtualDPad for four gamepad buttons.
  • KeyboardVirtualDPad for four keys.
  • MouseMove::default().digital() for discrete mouse movement.
  • MouseScroll::default().digital() for discrete mouse wheel movement.
• ActionDiff::ValueChanged is now ActionDiff::AxisChanged.
• ActionDiff::AxisPairChanged is now ActionDiff::DualAxisChanged.
• InputMap::iter has been split into iter_buttonlike, iter_axislike and iter_dual_axislike.
  • The same split has been done for InputMap::bindings and InputMap::actions.
• ActionState::axis_pair and AxisState::clamped_axis_pair now return a plain Vec2 rather than an Option<Vec2> for consistency with their single axis and buttonlike brethren.
• BasicInputs::clashed is now BasicInput::clashes_with to improve clarity
• BasicInputs::Group is now BasicInputs::Chord to improve clarity
• BasicInputs now only tracks buttonlike user inputs, and a new None variant has been added
• Bevy's bevy_gilrs feature is now optional.
  • it is still enabled by leafwing-input-manager's default features.
  • if you're using leafwing-input-manager with default_features = false, you can readd it by adding bevy/bevy_gilrs as a dependency.
• removed InputMap::build method in favor of new fluent builder pattern (see 'Usability: InputMap' for details).
• removed DeadZoneShape in favor of new dead zone processors (see 'Enhancements: Input Processors' for details).
• refactored the fields and methods of RawInputs to fit the new input types.
• removed Direction type in favor of bevy::math::primitives::Direction2d.
• removed MockInput::send_input methods, in favor of new input mocking APIs (see 'Usability: MockInput' for details).
• DualAxisData has been removed, and replaced with a simple Vec2 throughout
  • a new type with the DualAxisData name has been added, as a parallel to ButtonData and AxisData
• when no associated_gamepad is provided to an input map, find_gamepad will be called to attempt to search for a gamepad. Input from any gamepad will no longer work
• SummarizedActionState is now found in the action_diff module
• Axislike and DualAxislike inputs no longer send pressed / released ActionDiffs: only AxisChanged and DualAxisChanged events

Version 0.14.0

• updated to Bevy 0.14
• this is strictly a compatibility release to ease migration; you should consider upgrading to version 0.15 when possible

Version 0.13.3

Bugs (0.13.3)

• fixed a bug where DualAxis was being considered pressed even when its data was [0.0, 0.0].

Usability (0.13.3)

• added InputManagerBundle::with_map(InputMap) allowing you to create the bundle with the given InputMap and default ActionState.

Version 0.13.2

Usability (0.13.2)

• added with_threshold() for const SingleAxis creation.
• added horizontal_gamepad_face_buttons() and vertical_gamepad_face_buttons() for VirtualAxis, similar to VirtualDpad::gamepad_face_buttons().
• changed various creations of DualAxis, VirtualAxis, VirtualDpad into const functions as they should be:
  • left_stick(), right_stick() for DualAxis.
  • from_keys(), horizontal_arrow_keys(), vertical_arrow_keys(), ad(), ws(), horizontal_dpad(), vertical_dpad() for VirtualAxis.
  • arrow_keys(), wasd(), dpad(), gamepad_face_buttons(), mouse_wheel(), mouse_motion() for VirtualDpad.

Version 0.13.1

Breaking Changes

• removed the block_ui_interactions feature:
  • by default, this library will prioritize bevy::ui.
  • if you want to disable this priority, add the newly added no_ui_priority feature to your configuration.

Bugs (0.13.1)

• fixed a bug related to missing handling for ActionState::consumed

Usability (0.13.1)

• exported ActionState::action_data_mut_or_default()

Version 0.13.0

Breaking Changes (0.13.0)

• Modifier::Win has been renamed to Modifier::Super, consistent with KeyCode::SuperLeft and KeyCode::SuperRight.
• both KeyCode-based logical keybindings and ScanCode-based physical keybindings are no longer supported; please migrate to:
  • KeyCodes are now representing physical keybindings.
  • InputKind::Keyboard has been removed.
  • InputKind::KeyLocation has been removed; please use InputKind::PhysicalKey instead.
  • All ScanCodes and QwertyScanCodes have been removed; please use KeyCode instead:
    • all letter keys now follow the format KeyCode::Key<Letter>, e.g., ScanCode::K is now KeyCode::KeyK.
    • all number keys over letters now follow the format KeyCode::Digit<Number>, e.g., ScanCode::Key1 is now KeyCode::Digit1.
    • all arrow keys now follow the format KeyCode::Arrow<Direction>, e.g., ScanCode::Up is now KeyCode::ArrowUp.

Usability (0.13.0)

• bevy dependency has been bumped from 0.12 to 0.13.
• bevy_egui dependency has been bumped from 0.24 to 0.25.

Version 0.12.1

Usability (0.12.1)

• added a table detailing supported Bevy versions in the README.md
• added a feature flag asset allowing optional bevy::asset::Asset derive for the InputMap
• exported InputKind in prelude module

Bugs (0.12.1)

• fixed compilation issues with no-default-features
• fixed a bug related to incorrect updating of ActionState.

Version 0.12

Enhancements (0.12)

• improved deadzone handling for both DualAxis and SingleAxis deadzones
  • all deadzones now scale the input so that it is continuous.
  • DeadZoneShape::Cross handles each axis separately, making a per-axis "snapping" effect
  • an input that falls on the exact boundary of a deadzone is now considered inside it
• added support in ActionDiff for value and axis_pair changes

Usability (0.12)

• InputMaps are now constructed with (Action, Input) pairs, rather than (Input, Action) pairs, which directly matches the underlying data model
• registered types in the reflection system
• added InputMap::clear
• added ActionState::keys
• exported VirtualAxis in prelude module

Bugs (0.12)

• registered types in the reflection system
• added InputMap::clear
• fixed a bug related to incorrect axis data in Chord when not all buttons are pressed.

Code Quality (0.12)

• all non-insertion methods now take &A: Actionlike rather than A: Actionlike to avoid pointless cloning
• removed multimap dependency in favor of regular HashMap which allowed to derive Reflect for InputMap
• removed widely unused and untested dynamic actions functionality: this should be more feasible to implement directly with the changed architecture
• removed widely unused PressScheduler functionality: this can be re-implemented externally
• ActionState now stores a HashMap internally
  • ActionState::update now takes a HashMap<A, ActionState> rather than relying on ordering
  • InputMap::which_pressed now returns a HashMap<A, ActionState>
  • handle_clashes now takes a HashMap<A, ActionState>
  • ClashStrategy::UseActionOrder has been removed
• the action_state module has been pared down to something more reasonable in scope:
  • timing-related code now lives in its own timing module
  • ActionStateDriver code now lives in its own action_driver module
  • ActionDiff-related code now lives in its own action_diff module

Version 0.11.2

• fixed a bug with mouse motion and mouse wheel events being improperly counted
  • this was pre-existing, but dramatically worsened by the release of Bevy 0.12.1

Version 0.11.1

• bevy_egui integration and the egui feature flag have been added back with the release of bevy_egui 0.23.

Bugs (0.11.1)

• A disabled ToggleActions of one Action now does not release other Action's inputs.
• bevy_egui integration and the egui feature flag have been added back with the release of bevy_egui 0.23.

Version 0.11

Known Issues

• bevy_egui integration and the egui feature flag have been temporarily removed to ensure a timely release
• gamepad input mocking is not completely functional due to upstream changes: see #407
  • additional experiments and information would be helpful!

Breaking Changes (0.11)

• The UserInput::insert_at method has been removed: build this abstraction into your input binding menus if desired.
• InputMap::iter() now returns a simple iterator of (action, input) pairs
  • As a result, the InputMap::iter_inputs method has been removed.
• The InputMap::remove_at API now returns Some(removed_input), rather than just a bool.
• The serialization format for InputMap has changed. You will need to re-generate your input maps if you were storing these persistently.

Enhancements (0.11)

• Added DeadZoneShape for DualAxis which allows for different deadzones shapes: cross, rectangle, and ellipse.
• Added sensitivity for SingleAxis and DualAxis, allowing you to scale mouse, keypad and gamepad inputs differently for each action.
• Added a helper from_keys to VirtualAxis to simplify creating one from two keys

Usability (0.11)

• Added block_ui_interactions feature flag; when on, mouse input won't be read if any bevy_ui element has an active Interaction.
• Chords no longer have a max length.
• InputMap, UserInput and all of the contained types now implement Reflect. As a result, the trait bound on Actionlike has been changed from TypePath to Reflect.

Bugs (0.11)

• Fixed system order ambiguity between bevy_ui and update_action_state systems
• The input values of axis inputs in a Chord are now prioritized over buttons
• Fixed unassigned InputMapss not receiving input from all connected gamepads

Performance (0.11)

• Removed the petitset dependency in favor of a MultiMap to reduce stack size of input types.
  • As a result, the Actionlike trait now has the additional Hash and Eq trait bounds
  • UserInput::Chord now stores a simple Vec of InputKinds

Docs (0.11)

• Fixed invalid example code in README
• Added example for setting default controls
• Added example for registering gamepads in a local multiplayer fashion

Version 0.10

Usability (0.10)

• bevy dependency has been bumped from 0.10 to 0.11.
• ActionLike now requires Bevy's TypePath trait. Your actions will now need to derive Reflect or TypePath. See bevy#7184
• QwertyScanCode has had its variants renamed to match bevy's KeyCode variants. See bevy#8792
• Makes run_if_enabled public.

Enhancements (0.10)

• Changed entity field of ActionStateDriver to targets: ActionStateDriverTarget with variants for 0, 1, or multiple targets, to allow for one driver to update multiple entities if needed.
• Added builder-style functions to SingleAxis, DualAxis, and VirtualDPad that invert their output values, allowing, for example, binding inverted camera controls.

Docs (0.10)

• Added example for driving cursor position action from another entity.

Version 0.9.3

Bugs (0.9.3)

• Changed Rotation to be stored in millionths of a degree instead of tenths of a degree in order to reduce rounding errors.

Usability (0.9.3)

• Added VirtualAxis::horizontal_dpad() and VirtualAxis::vertical_dpad().
• Do not read mouse input if any bevy_ui element have active Interaction.

Version 0.9.2

Bugs (0.9.2)

• Fixed DualAxis inputs so deadzones apply across both axes, and filter out-of-range values correctly.

Version 0.9.1

Usability (0.9.1)

• Added common run conditions for actions that mirrors input conditions in Bevy.

Version 0.9.0

Usability (0.9.0)

• Added ActionState::consume_all() to consume all actions.
• bevy_egui dependency has been bumped from 0.19 to 0.20.
• bevy dependency has been bumped from 0.9 to 0.10.

Enhancements (0.9.0)

• Added scan code support, which enables you to define keybindings depending on the key position rather than the key output. This is useful to make the keybindings layout-independent and is commonly used for the WASD movement controls.
  • Use ScanCode to define the raw scan code values.
  • Use QwertyScanCode to define the scan code by the name of the key on the US QWERTY keyboard layout.
• The Actionlike::N_VARIANTS constant has been changed to a function.
• Added the DynAction type and various companions to enable more advanced use cases.

Version 0.8.0

Usability (0.8.0)

• bevy_egui dependency has been bumped from 0.18 to 0.19.

Version 0.7.2

Usability (0.7.2)

• Added custom implementation of the Serialize and Deserialize traits for InputMap to make the format more human readable.
• Added TypeUuid for InputMap to be able use it as asset without wrapper
• ActionState and its fields now implement Reflect. The type is automatically registered when the InputManagerPlugin is added.
• Added PressScheduler, used to defer action presses until the start of the next frame to ease scheduling.

Version 0.7.1

Bugs (0.7.1)

• egui feature now works correctly and more robustly if an EguiPlugin is not actually enabled.

Version 0.7

Enhancements (0.7)

• Added VirtualAxis struct that can be supplied to an InputMap to trigger on two direction-representing inputs. 1-dimensional equivalent to VirtualDPad.

Usability (0.7)

• Added egui feature to not take specific input sources into account when egui is using them. For example, when the user clicks on a widget, the actions associated with the mouse will not be taken into account.
• InputStreams no longer stores an Option to an input stream type: all fields other than associated_gamepad are now required. This was not useful in practice and added significant complexity.

Version 0.6.1

Bugs (0.6.1)

• no longer print "real clash" due to a missed debugging statement

Version 0.6

Enhancements (0.6)

• Added the Modifier enum, to ergonomically capture the notion of "either control/alt/shift/windows key".
  • The corresponding InputKind::Modifier variant was added to match.
  • You can conveniently construct these using the InputKind::modified or InputMap::insert_modified methods.

Usability (0.6)

• Implemented Eq for Timing and InputMap.
• Held ActionState inputs will now be released when an InputMap is removed.
• Improve ToggleActions.
  • Make _phantom field public and rename into phantom.
  • Add ToggleActions::ENABLED and ToggleActions::DISABLED.
• Added SingleAxis::negative_only and SingleAxis::positive_only for triggering separate actions for each direction of an axis.
• ActionData::action_data now returns a reference, rather than a clone, for consistency and explicitness
• added with_deadzone methods to configure the deadzones for both SingleAxis and DualAxis inputs

Version 0.5.2

Bug fixes (0.5.2)

• Fixed gamepad axes not filtering out inputs outside of the axis deadzone.
• Fixed DualAxis::right_stick() returning the y axis for the left stick.

Version 0.5.1

Bug fixes (0.5.1)

• removed a missed println statement spamming "real conflict" that had been missed

Version 0.5

Enhancements (0.5)

• Added gamepad axis support.
  • Use the new SingleAxis and DualAxis types / variants.
• Added mousewheel and mouse motion support.
  • Use the new SingleAxis and DualAxis types / variants when you care about the continuous values.
  • Use the new MouseWheelDirection enum as an InputKind.
• Added SingleAxis and DualAxis structs that can be supplied to an InputMap to trigger on axis inputs.
• Added VirtualDPad struct that can be supplied to an InputMap to trigger on four direction-representing inputs.
• Added ActionState::action_axis_pair() which can return an AxisPair containing the analog values of a SingleAxis, DualAxis, or VirtualDPad.
• Added ActionState::action_value() which represents the floating point value of any action:
  • 1.0 or 0.0 for pressed or unpressed button-like inputs
  • a value (typically) in the range -1.0..=1.0 for a single axis representing its analog input
  • or a value (typically) in the range 0.0..=1.0 for a dual axis representing the magnitude (length) of its vector.

Usability (0.5)

• If no gamepad is registered to a specific InputMap, inputs from any gamepad in the Gamepads resource will be used.
• Removed the ActionState::reasons_pressed API.
  • This API was quite complex, not terribly useful and had nontrivial performance overhead.
  • This was not needed for axislike inputs in the end.
• Added Direction::try_new() to fallibly create a new Direction struct (which cannot be created from the zero vector).
• Removed the InputMode enum.
  • This was poorly motivated and had no internal usages.
  • This could not accurately represent more complex compound input types.
• ButtonKind was renamed to InputKind to reflect the new non-button input types.
• Renamed AxisPair to DualAxisData.
  • Vec2::new now takes two f32 values for ergonomic reasons.
  • Use DualAxisData::from_xy to construct this directly from a Vec2 as before.
• Rotation is now measured from the positive x axis in a counterclockwise direction. This applies to both Rotation and Direction.
  • This increases consistency with glam and makes trigonometry easier.
• Added Direction::try_from which never panics; consider using this in place of Direction::new.
• Converting from a Direction (which uses a Vec2 of f32's internally) to a Rotation (which uses exact decidegrees) now has special cases to ensure all eight cardinal directions result in exact degrees.
  • For example, a unit vector pointing to the Northeast now always converts to a Direction with exactly 1350 decidegrees.
  • Rounding errors may still occur when converting from arbitrary directions to the other 3592 discrete decidegrees.
• InputStreams and MutableInputStreams no longer store e.g. Option<Res<Input<MouseButton>>>, and instead simply store Res<Input<MouseButton>>
  • This makes them much easier to work with and dramatically simplifies internal logic.
• InputStreams::from_world no longer requires &mut World, as it does not require mutable access to any resources.
• Renamed InputMocking::send_input_to_gamepad and InputMocking::release_input_for_gamepad to InputMocking::send_input_as_gamepad and InputMocking::send_input_as_gamepad.
• Added the guess_gamepad method to InputStreams and MutableInputStreams, which attempts to find an appropriate gamepad to use.
• InputMocking::pressed and pressed_for_gamepad no longer require &mut self.
• UserInput::raw_inputs now returns a RawInputs struct, rather than a tuple struct.
• The mouse and keyboard fields on the two InputStreams types are now named mouse_button and keycode respectively.

Bug fixes

• mocked inputs are now sent at the low-level Events form, rather than in their Input format.
  • this ensures that user code that is reading these events directly can be tested accurately.

Version 0.4.1

Bug fixes (0.4.1)

• fixed a compilation error caused by mistakenly renaming the macros crate

Version 0.4

Usability (0.4)

• reduced required derive_more features
• removed thiserror dependency
• the order of all methods on InputMap is now (input, action), rather than (action, input) to better match user mental models
  • this is a map-like struct: one presses KeyCode::F to Actions::PayRespects, not the other way around!
  • this includes the order of all paired tuples, including the returned values

Bug fixes (0.4)

• fixed serious bug that broke all functionality relating to durations that buttons were pressed or released for
  • ActionState::tick now takes the Instant of both the current and previous frame, rather than just the current
• InputManagerPlugin no longer panics when time does not have a previous update
  • this is useful as it ensures bevy_inspector_egui compatibility!

Docs (0.4)

• properly documented the ToggleActions functionality, for dynamically enabling and disabling actions
• added doc examples to ActionStateDriver, which allows you to trigger actions based on entity properties
• document the need to add system ordering when you have other functionality running during CoreStage::PreUpdate
• hint to users that they may want to use multiple Actionlike enums

Version 0.3

Enhancements (0.3)

• added reasons_pressed API on ActionState, which records the triggering inputs
  • you can use this to extract exact input information from analog inputs (like triggers or joysticks)
• added the ability to release user inputs during input mocking
• added ActionState::consume(action), which allows you to consume a pressed action, ensuring it is not pressed until after it is otherwise released
• added geometric primitives (Direction and Rotation) for working with rotations in 2 dimensions
  • stay tuned for first-class directional input support!

Usability (0.3)

• if desired, users are now able to use the ActionState and InputMap structs as standalone resources
• reverted change from by-reference to by-value APIs for Actionlike types
  • this is more ergonomic (derive Copy when you can!), and somewhat faster in the overwhelming majority of uses
• relaxed Hash and Eq bounds on Actionlike
• InputManagerPlugin::run_in_state was replaced with ToggleActions<A: Actionlike> resource which controls whether or not the [ActionState] / [InputMap] pairs of type A are active.
• ActionState::state and set_state methods renamed to button_state and set_button_state for clarity
• simplified VirtualButtonState into a trivial enum ButtonState
  • other metadata (e.g. timing information and reasons pressed) is stored in the ActionData struct
  • users can now access the ActionData struct directly for each action in a ActionState struct, allowing full manual control for unusual needs
• removed a layer of indirection for fetching timing information: simply call action_state.current_duration(&Action::Jump), rather than action_state.button_state(Action::Jump).current_duration()
• fleshed out ButtonState API for better parity with ActionState
• removed UserInput::Null: this was never helpful and bloated match statements
  • insert this resource when you want to suppress input collection, and remove it when you're done
• renamed the InputManagerSystem::Reset system label to InputManagerSystem::Tick.
• refactored InputMap
  • removed methods that works with specific input mode.
  • removed n_registered, use get(action).len() instead.
  • added insert_at / remove_at to insert / remove input at specific index.
  • added remove remove input for specific mapping.
  • use usize for sizes as in other Rust containers.
• added UserInput::raw_inputs, which breaks down a UserInput into the constituent Bevy types (e.g. KeyCode and MouseButton)

Bug fixes (0.3)

• the PartialOrd implementation of Timing now correctly compares values on the basis of the current duration that the button has been held / released for

Version 0.2

Enhancements (0.2)

• configure how "clashing" inputs should be handled with the ClashStrategy field of your InputMap
  • very useful for working with modifier keys
  • if two actions are triggered
• ergonomic input mocking API at both the App and World level using the MockInputs trait
• send ActionState across the network in a space-efficient fashion using the ActionDiff struct
  • check out (or directly use) the process_action_diff and generate_action_diff systems to convert these to and from ActionStates
  • add InputManagerPlugin::server() to your server App for a stripped down version of the input management functionality

Usability (0.2)

• InputMap::new() and InputMap::insert_multiple now accept an iterator of (action, input) tuples for more natural construction
• better decoupled InputMap and ActionState, providing an InputMap::which_pressed API and allowing ActionState::update to operate based on any HashSet<A: Actionlike> of pressed virtual buttons that you pass in
• InputMap now uses a collected InputStreams struct in all of its methods, and input methods are now optional
• InputManagerPlugin now works even if some input stream resources are missing
• added the input_pressed method to InputMap, to check if a single input is pressed
• renamed InputMap::assign_gamepad to InputMap::set_gamepad for consistency and clarity (it does not uniquely assign a gamepad)
• removed strum dependency by reimplementing the functionality, allowing users to define actions with only the Actionlike trait
• added the get_at and index methods on the Actionlike trait, allowing you to fetch a specific action by its position in the defining enum and vice versa
• Copy bound on Actionlike trait relaxed to Clone, allowing you to store non-copy data in your enum variants
• Clone, PartialEq and Debug trait impls for ActionState
• get_pressed, get_just_pressed, get_released and get_just_released methods on ActionState, for conveniently checking many action states at once

Bug fixes (0.2)

• the ActionState component is no longer marked as Changed every frame
• InputManagerPlugin::run_in_state now actually works!
• virtually all methods now take actions and inputs by reference, rather than by ownership, eliminating unnecessary copies

Version 0.1.2

Usability (0.1.2)

• added set_state method, allowing users to transfer VirtualButtonState between ActionState without losing Timing information

Bug fixes (0.1.2)

• fixed minor mistakes in documentation

Version 0.1.1

Bug fixes (0.1.1)

• fix failed strum re-export; users will need to pull in the derive macro EnumIter themselves
  • thanks to @Shatur for noticing this

Version 0.1

• Released!