Upgrade to Bevy 0.15.0-dev.

Cargo.toml

@@ -45,7 +45,7 @@ egui = ['dep:bevy_egui']
 
 [dependencies]
 leafwing_input_manager_macros = { path = "macros", version = "0.15.1" }
-bevy = { version = "0.14.0-rc.3", default-features = false, features = [
+bevy = { version = "0.15.0-dev", default-features = false, features = [
  "serialize",
 ] }
 bevy_egui = { version = "0.29", optional = true }
@@ -63,7 +63,7 @@ dyn-hash = "0.2"
 once_cell = "1.19"
 
 [dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = [
+bevy = { version = "0.15.0-dev", default-features = false, features = [
  "bevy_asset",
  "bevy_sprite",
  "bevy_text",

examples/axis_inputs.rs

@@ -32,7 +32,7 @@ fn spawn_player(mut commands: Commands) {
  // Let's bind the left stick for the move action
  .with_dual_axis(Action::Move, GamepadStick::LEFT)
  // And then bind the right gamepad trigger to the throttle action
- .with(Action::Throttle, GamepadButtonType::RightTrigger2)
+ .with(Action::Throttle, GamepadButton::RightTrigger2)
  // And we'll use the right stick's x-axis as a rudder control
  .with_axis(
  // Add an AxisDeadzone to process horizontal values of the right stick.

examples/default_controls.rs

@@ -27,8 +27,8 @@ impl PlayerAction {
 
  // Default gamepad input bindings
  input_map.insert_dual_axis(Self::Run, GamepadStick::LEFT);
- input_map.insert(Self::Jump, GamepadButtonType::South);
- input_map.insert(Self::UseItem, GamepadButtonType::RightTrigger2);
+ input_map.insert(Self::Jump, GamepadButton::South);
+ input_map.insert(Self::UseItem, GamepadButton::RightTrigger2);
 
  // Default kbm input bindings
  input_map.insert_dual_axis(Self::Run, VirtualDPad::wasd());

examples/mouse_motion.rs

@@ -22,7 +22,7 @@ fn setup(mut commands: Commands) {
  // via the `MouseMoveDirection` enum.
  let input_map = InputMap::default().with_dual_axis(CameraMovement::Pan, MouseMove::default());
  commands
- .spawn(Camera2dBundle::default())
+ .spawn(Camera2d)
  .insert(InputManagerBundle::with_map(input_map));
 
  commands.spawn(SpriteBundle {

examples/mouse_wheel.rs

@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, render::camera::ScalingMode};
 use leafwing_input_manager::prelude::*;
 
 fn main() {
@@ -33,7 +33,7 @@ fn setup(mut commands: Commands) {
  // Or even a digital dual-axis input!
  .with_dual_axis(CameraMovement::Pan, MouseScroll::default().digital());
  commands
- .spawn(Camera2dBundle::default())
+ .spawn(Camera2d)
  .insert(InputManagerBundle::with_map(input_map));
 
  commands.spawn(SpriteBundle {
@@ -55,7 +55,10 @@ fn zoom_camera(
  // We want to zoom in when we use mouse wheel up,
  // so we increase the scale proportionally
  // Note that the projection's scale should always be positive (or our images will flip)
- camera_projection.scale *= 1. - zoom_delta * CAMERA_ZOOM_RATE;
+ match camera_projection.scaling_mode {
+ ScalingMode::WindowSize(ref mut scale) => *scale *= 1. - zoom_delta * CAMERA_ZOOM_RATE,
+ ref mut scale => *scale = ScalingMode::WindowSize(1. - zoom_delta * CAMERA_ZOOM_RATE),
+ }
 }
 
 fn pan_camera(mut query: Query<(&mut Transform, &ActionState<CameraMovement>), With<Camera2d>>) {

examples/multiplayer.rs

@@ -30,7 +30,7 @@ struct PlayerBundle {
 }
 
 impl PlayerBundle {
- fn input_map(player: Player) -> InputMap<Action> {
+ fn input_map(player: Player, gamepad_0: Entity, gamepad_1: Entity) -> InputMap<Action> {
  let mut input_map = match player {
  Player::One => InputMap::new([
  (Action::Left, KeyCode::KeyA),
@@ -42,36 +42,39 @@ impl PlayerBundle {
  // and gracefully handle disconnects
  // Note that this step is not required:
  // if it is skipped, all input maps will read from all connected gamepads
- .with_gamepad(Gamepad { id: 0 }),
+ .with_gamepad(gamepad_0),
  Player::Two => InputMap::new([
  (Action::Left, KeyCode::ArrowLeft),
  (Action::Right, KeyCode::ArrowRight),
  (Action::Jump, KeyCode::ArrowUp),
  ])
- .with_gamepad(Gamepad { id: 1 }),
+ .with_gamepad(gamepad_1),
  };
 
  // Each player will use the same gamepad controls, but on separate gamepads.
  input_map.insert_multiple([
- (Action::Left, GamepadButtonType::DPadLeft),
- (Action::Right, GamepadButtonType::DPadRight),
- (Action::Jump, GamepadButtonType::DPadUp),
- (Action::Jump, GamepadButtonType::South),
+ (Action::Left, GamepadButton::DPadLeft),
+ (Action::Right, GamepadButton::DPadRight),
+ (Action::Jump, GamepadButton::DPadUp),
+ (Action::Jump, GamepadButton::South),
  ]);
 
  input_map
  }
 }
 
 fn spawn_players(mut commands: Commands) {
+ let gamepad_0 = commands.spawn(()).id();
+ let gamepad_1 = commands.spawn(()).id();
+
  commands.spawn(PlayerBundle {
  player: Player::One,
- input_manager: InputManagerBundle::with_map(PlayerBundle::input_map(Player::One)),
+ input_manager: InputManagerBundle::with_map(PlayerBundle::input_map(Player::One, gamepad_0, gamepad_1)),
  });
 
  commands.spawn(PlayerBundle {
  player: Player::Two,
- input_manager: InputManagerBundle::with_map(PlayerBundle::input_map(Player::Two)),
+ input_manager: InputManagerBundle::with_map(PlayerBundle::input_map(Player::Two, gamepad_0, gamepad_1)),
  });
 }
 

examples/register_gamepads.rs

@@ -19,45 +19,50 @@ enum Action {
 }
 
 // This is used to check if a player already exists and which entity to disconnect
+//
+// This maps gamepad entity to player.
 #[derive(Resource, Default)]
-struct JoinedPlayers(pub HashMap<Gamepad, Entity>);
+struct JoinedPlayers(pub HashMap<Entity, Entity>);
 
 #[derive(Component)]
 struct Player {
  // This gamepad is used to index each player
- gamepad: Gamepad,
+ gamepad: Entity,
 }
 
 fn join(
  mut commands: Commands,
  mut joined_players: ResMut<JoinedPlayers>,
- gamepads: Res<Gamepads>,
- button_inputs: Res<ButtonInput<GamepadButton>>,
+ gamepads: Query<(Entity, &Gamepad)>,
 ) {
- for gamepad in gamepads.iter() {
+ for (gamepad_entity, gamepad) in gamepads.iter() {
  // Join the game when both bumpers (L+R) on the controller are pressed
  // We drop down the Bevy's input to get the input from each gamepad
- if button_inputs.pressed(GamepadButton::new(gamepad, GamepadButtonType::LeftTrigger))
- && button_inputs.pressed(GamepadButton::new(gamepad, GamepadButtonType::RightTrigger))
+ if gamepad.pressed(GamepadButton::LeftTrigger)
+ && gamepad.pressed(GamepadButton::RightTrigger)
  {
  // Make sure a player cannot join twice
- if !joined_players.0.contains_key(&gamepad) {
- println!("Player {} has joined the game!", gamepad.id);
+ if !joined_players.0.contains_key(&gamepad_entity) {
+ println!("Player {} has joined the game!", gamepad_entity);
 
  let input_map = InputMap::new([
- (Action::Jump, GamepadButtonType::South),
- (Action::Disconnect, GamepadButtonType::Select),
+ (Action::Jump, GamepadButton::South),
+ (Action::Disconnect, GamepadButton::Select),
  ])
  // Make sure to set the gamepad or all gamepads will be used!
- .with_gamepad(gamepad);
+ .with_gamepad(gamepad_entity);
  let player = commands
  .spawn(InputManagerBundle::with_map(input_map))
- .insert(Player { gamepad })
+ .insert(Player {
+ gamepad: gamepad_entity,
+ })
  .id();
 
  // Insert the created player and its gamepad to the hashmap of joined players
  // Since uniqueness was already checked above, we can insert here unchecked
- joined_players.0.insert_unique_unchecked(gamepad, player);
+ joined_players
+ .0
+ .insert_unique_unchecked(gamepad_entity, player);
  }
  }
  }
@@ -67,7 +72,7 @@ fn jump(action_query: Query<(&ActionState<Action>, &Player)>) {
  // Iterate through each player to see if they jumped
  for (action_state, player) in action_query.iter() {
  if action_state.just_pressed(&Action::Jump) {
- println!("Player {} jumped!", player.gamepad.id);
+ println!("Player {} jumped!", player.gamepad);
  }
  }
 }
@@ -85,7 +90,7 @@ fn disconnect(
  commands.entity(player_entity).despawn();
  joined_players.0.remove(&player.gamepad);
 
- println!("Player {} has disconnected!", player.gamepad.id);
+ println!("Player {} has disconnected!", player.gamepad);
  }
  }
 }

examples/send_actions_over_network.rs

@@ -6,7 +6,7 @@
 //! Note that [`ActionState`] can also be serialized and sent directly.
 //! This approach will be less bandwidth efficient, but involve less complexity and CPU work.
 
-use bevy::ecs::event::ManualEventReader;
+use bevy::ecs::event::EventCursor;
 use bevy::input::InputPlugin;
 use bevy::prelude::*;
 use leafwing_input_manager::action_diff::ActionDiffEvent;
@@ -137,13 +137,13 @@ fn spawn_player(mut commands: Commands) {
 fn send_events<A: Send + Sync + 'static + Debug + Clone + Event>(
  client_app: &App,
  server_app: &mut App,
- reader: Option<ManualEventReader<A>>,
-) -> ManualEventReader<A> {
+ reader: Option<EventCursor<A>>,
+) -> EventCursor<A> {
  let client_events: &Events<A> = client_app.world().resource();
  let mut server_events: Mut<Events<A>> = server_app.world_mut().resource_mut();
 
  // Get an event reader, one way or another
- let mut reader = reader.unwrap_or_else(|| client_events.get_reader());
+ let mut reader = reader.unwrap_or_else(|| client_events.get_cursor());
 
  // Push the clients' events to the server
  for client_event in reader.read(client_events) {

examples/single_player.rs

@@ -74,34 +74,34 @@ impl PlayerBundle {
 
  // Movement
  input_map.insert(Up, KeyCode::ArrowUp);
- input_map.insert(Up, GamepadButtonType::DPadUp);
+ input_map.insert(Up, GamepadButton::DPadUp);
 
  input_map.insert(Down, KeyCode::ArrowDown);
- input_map.insert(Down, GamepadButtonType::DPadDown);
+ input_map.insert(Down, GamepadButton::DPadDown);
 
  input_map.insert(Left, KeyCode::ArrowLeft);
- input_map.insert(Left, GamepadButtonType::DPadLeft);
+ input_map.insert(Left, GamepadButton::DPadLeft);
 
  input_map.insert(Right, KeyCode::ArrowRight);
- input_map.insert(Right, GamepadButtonType::DPadRight);
+ input_map.insert(Right, GamepadButton::DPadRight);
 
  // Abilities
  input_map.insert(Ability1, KeyCode::KeyQ);
- input_map.insert(Ability1, GamepadButtonType::West);
+ input_map.insert(Ability1, GamepadButton::West);
  input_map.insert(Ability1, MouseButton::Left);
 
  input_map.insert(Ability2, KeyCode::KeyW);
- input_map.insert(Ability2, GamepadButtonType::North);
+ input_map.insert(Ability2, GamepadButton::North);
  input_map.insert(Ability2, MouseButton::Right);
 
  input_map.insert(Ability3, KeyCode::KeyE);
- input_map.insert(Ability3, GamepadButtonType::East);
+ input_map.insert(Ability3, GamepadButton::East);
 
  input_map.insert(Ability4, KeyCode::Space);
- input_map.insert(Ability4, GamepadButtonType::South);
+ input_map.insert(Ability4, GamepadButton::South);
 
  input_map.insert(Ultimate, KeyCode::KeyR);
- input_map.insert(Ultimate, GamepadButtonType::LeftTrigger2);
+ input_map.insert(Ultimate, GamepadButton::LeftTrigger2);
 
  input_map
  }

examples/twin_stick_controller.rs

@@ -48,7 +48,7 @@ impl PlayerAction {
  // Default gamepad input bindings
  input_map.insert_dual_axis(Self::Move, GamepadStick::LEFT);
  input_map.insert_dual_axis(Self::Look, GamepadStick::RIGHT);
- input_map.insert(Self::Shoot, GamepadButtonType::RightTrigger);
+ input_map.insert(Self::Shoot, GamepadButton::RightTrigger);
 
  // Default kbm input bindings
  input_map.insert_dual_axis(Self::Move, VirtualDPad::wasd());
@@ -132,7 +132,7 @@ fn player_mouse_look(
  let player_position = player_transform.translation;
  if let Some(p) = window
  .cursor_position()
- .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
+ .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor).ok())
  .and_then(|ray| {
  Some(ray).zip(ray.intersect_plane(player_position, InfinitePlane3d::new(Vec3::Y)))
  })
@@ -182,11 +182,9 @@ struct Player;
 
 fn setup_scene(mut commands: Commands) {
  // We need a camera
- commands.spawn(Camera3dBundle {
- transform: Transform::from_xyz(0.0, 10.0, 15.0)
- .looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
- ..default()
- });
+ commands
+ .spawn(Camera3d::default())
+ .insert(Transform::from_xyz(0.0, 10.0, 15.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y));
 
  // And a player
  commands.spawn(Player).insert(Transform::default());

examples/virtual_dpad.rs

@@ -31,8 +31,8 @@ fn spawn_player(mut commands: Commands) {
  VirtualDPad::new(
  KeyCode::KeyW,
  KeyCode::KeyS,
- GamepadButtonType::DPadLeft,
- GamepadButtonType::DPadRight,
+ GamepadButton::DPadLeft,
+ GamepadButton::DPadRight,
  ),
  );
  commands

macros/src/typetag.rs

@@ -42,7 +42,7 @@ pub(crate) fn expand_serde_typetag(input: &ItemImpl) -> syn::Result<TokenStream>
  ) {
  #crate_path::typetag::Registry::register(
  registry,
- #ident,
+ (#ident).into(),
  |de| Ok(::std::boxed::Box::new(
  ::bevy::reflect::erased_serde::deserialize::<#self_ty>(de)?,
  )),