Update Rust crate leafwing-input-manager to 0.16.0

[renovate]

This PR contains the following updates:

Package	Type	Update	Change
leafwing-input-manager (source)	dependencies	minor	0.6.1 -> 0.16.0

---

Release Notes

leafwing-studios/leafwing-input-manager (leafwing-input-manager)

v0.16.0

v0.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

v0.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

v0.14.0

Compare Source

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

v0.13.3

Compare Source

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.

v0.13.2

Compare Source

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.

v0.13.1

Compare Source

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()

v0.13.0

Compare Source

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.

v0.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.

v0.11.2

Compare Source

• 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

v0.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.

v0.10.0

Compare Source

v0.9.3

Compare Source

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.

v0.9.2

Compare Source

Bugs (0.9.2)

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

v0.9.1

Compare Source

Usability (0.9.1)

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

v0.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.

v0.8.0

Usability (0.8.0)

• bevy_egui dependency has been bumped from 0.18 to 0.19.

v0.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.

v0.7.1

Bugs (0.7.1)

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

---

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.