Picking event ordering

crates/bevy_picking/src/focus.rs

@@ -1,11 +1,13 @@
 //! Determines which entities are being hovered by which pointers.
 
-use std::{collections::BTreeMap, fmt::Debug};
+use std::{
+ collections::{BTreeMap, HashSet},
+ fmt::Debug,
+};
 
 use crate::{
  backend::{self, HitData},
- events::PointerCancel,
- pointer::{PointerId, PointerInteraction, PointerPress},
+ pointer::{PointerAction, PointerId, PointerInput, PointerInteraction, PointerPress},
  Pickable,
 };
 
@@ -63,7 +65,7 @@ pub fn update_focus(
  pickable: Query<&Pickable>,
  pointers: Query<&PointerId>,
  mut under_pointer: EventReader<backend::PointerHits>,
- mut cancellations: EventReader<PointerCancel>,
+ mut pointer_input: EventReader<PointerInput>,
  // Local
  mut over_map: Local<OverMap>,
  // Output
@@ -76,7 +78,7 @@ pub fn update_focus(
  &mut over_map,
  &pointers,
  );
- build_over_map(&mut under_pointer, &mut over_map, &mut cancellations);
+ build_over_map(&mut under_pointer, &mut over_map, &mut pointer_input);
  build_hover_map(&pointers, pickable, &over_map, &mut hover_map);
 }
 
@@ -109,9 +111,18 @@ fn reset_maps(
 fn build_over_map(
  backend_events: &mut EventReader<backend::PointerHits>,
  pointer_over_map: &mut Local<OverMap>,
- pointer_cancel: &mut EventReader<PointerCancel>,
+ pointer_input: &mut EventReader<PointerInput>,
 ) {
- let cancelled_pointers: Vec<PointerId> = pointer_cancel.read().map(|p| p.pointer_id).collect();
+ let cancelled_pointers: HashSet<PointerId> = pointer_input
+ .read()
+ .filter_map(|p| {
+ if let PointerAction::Canceled = p.action {
+ Some(p.pointer_id)
+ } else {
+ None
+ }
+ })
+ .collect();
 
  for entities_under_pointer in backend_events
  .read()

crates/bevy_picking/src/input/mod.rs

@@ -68,10 +68,6 @@ impl Plugin for InputPlugin {
  (
  mouse::mouse_pick_events.run_if(InputPlugin::is_mouse_enabled),
  touch::touch_pick_events.run_if(InputPlugin::is_touch_enabled),
- // IMPORTANT: the commands must be flushed after `touch_pick_events` is run
- // because we need pointer spawning to happen immediately to prevent issues with
- // missed events during drag and drop.
- apply_deferred,
  )
  .chain()
  .in_set(PickSet::Input),

crates/bevy_picking/src/input/mouse.rs

@@ -1,13 +1,13 @@
 //! Provides sensible defaults for mouse picking inputs.
 
 use bevy_ecs::prelude::*;
-use bevy_input::{mouse::MouseButtonInput, prelude::*, ButtonState};
+use bevy_input::{prelude::*, ButtonState};
 use bevy_math::Vec2;
 use bevy_render::camera::RenderTarget;
-use bevy_window::{CursorMoved, PrimaryWindow, Window, WindowRef};
+use bevy_window::{PrimaryWindow, WindowEvent, WindowRef};
 
 use crate::{
- pointer::{InputMove, InputPress, Location, PointerButton, PointerId},
+ pointer::{Location, PointerAction, PointerButton, PointerId, PointerInput, PressDirection},
  PointerBundle,
 };
 
@@ -19,49 +19,97 @@ pub fn spawn_mouse_pointer(mut commands: Commands) {
 /// Sends mouse pointer events to be processed by the core plugin
 pub fn mouse_pick_events(
  // Input
- windows: Query<(Entity, &Window), With<PrimaryWindow>>,
- mut cursor_moves: EventReader<CursorMoved>,
+ mut window_events: EventReader<WindowEvent>,
+ primary_window: Query<Entity, With<PrimaryWindow>>,
+ // Locals
  mut cursor_last: Local<Vec2>,
- mut mouse_inputs: EventReader<MouseButtonInput>,
  // Output
- mut pointer_move: EventWriter<InputMove>,
- mut pointer_presses: EventWriter<InputPress>,
+ mut pointer_events: EventWriter<PointerInput>,
 ) {
- for event in cursor_moves.read() {
- pointer_move.send(InputMove::new(
- PointerId::Mouse,
- Location {
- target: RenderTarget::Window(WindowRef::Entity(event.window))
- .normalize(Some(
- match windows.get_single() {
- Ok(w) => w,
- Err(_) => continue,
- }
- .0,
- ))
- .unwrap(),
- position: event.position,
- },
- event.position - *cursor_last,
- ));
- *cursor_last = event.position;
- }
-
- for input in mouse_inputs.read() {
- let button = match input.button {
- MouseButton::Left => PointerButton::Primary,
- MouseButton::Right => PointerButton::Secondary,
- MouseButton::Middle => PointerButton::Middle,
- MouseButton::Other(_) | MouseButton::Back | MouseButton::Forward => continue,
- };
-
- match input.state {
- ButtonState::Pressed => {
- pointer_presses.send(InputPress::new_down(PointerId::Mouse, button));
+ for window_event in window_events.read() {
+ match window_event {
+ // Handle the cursor entering the window
+ WindowEvent::CursorEntered(event) => {
+ let location = Location {
+ target: match RenderTarget::Window(WindowRef::Entity(event.window))
+ .normalize(primary_window.get_single().ok())
+ {
+ Some(target) => target,
+ None => continue,
+ },
+ position: *cursor_last, // Note, this is a hack until winit starts providing locations
+ };
+ pointer_events.send(PointerInput::new(
+ PointerId::Mouse,
+ location,
+ PointerAction::EnteredWindow,
+ ));
+ }
+ // Handle curcor leaving the window
+ WindowEvent::CursorLeft(event) => {
+ let location = Location {
+ target: match RenderTarget::Window(WindowRef::Entity(event.window))
+ .normalize(primary_window.get_single().ok())
+ {
+ Some(target) => target,
+ None => continue,
+ },
+ position: *cursor_last, // Note, this is a hack until winit starts providing locations
+ };
+ pointer_events.send(PointerInput::new(
+ PointerId::Mouse,
+ location,
+ PointerAction::LeftWindow,
+ ));
+ }
+ // Handle cursor movement events
+ WindowEvent::CursorMoved(event) => {
+ let location = Location {
+ target: match RenderTarget::Window(WindowRef::Entity(event.window))
+ .normalize(primary_window.get_single().ok())
+ {
+ Some(target) => target,
+ None => continue,
+ },
+ position: event.position,
+ };
+ pointer_events.send(PointerInput::new(
+ PointerId::Mouse,
+ location,
+ PointerAction::Moved {
+ delta: event.position - *cursor_last,
+ },
+ ));
+ *cursor_last = event.position;
  }
- ButtonState::Released => {
- pointer_presses.send(InputPress::new_up(PointerId::Mouse, button));
+ // Handle mouse button press events
+ WindowEvent::MouseButtonInput(input) => {
+ let location = Location {
+ target: match RenderTarget::Window(WindowRef::Entity(input.window))
+ .normalize(primary_window.get_single().ok())
+ {
+ Some(target) => target,
+ None => continue,
+ },
+ position: *cursor_last,
+ };
+ let button = match input.button {
+ MouseButton::Left => PointerButton::Primary,
+ MouseButton::Right => PointerButton::Secondary,
+ MouseButton::Middle => PointerButton::Middle,
+ MouseButton::Other(_) | MouseButton::Back | MouseButton::Forward => continue,
+ };
+ let direction = match input.state {
+ ButtonState::Pressed => PressDirection::Down,
+ ButtonState::Released => PressDirection::Up,
+ };
+ pointer_events.send(PointerInput::new(
+ PointerId::Mouse,
+ location,
+ PointerAction::Pressed { direction, button },
+ ));
  }
+ _ => {}
  }
  }
 }

crates/bevy_picking/src/input/touch.rs

@@ -3,73 +3,89 @@
 use bevy_ecs::prelude::*;
 use bevy_hierarchy::DespawnRecursiveExt;
 use bevy_input::touch::{TouchInput, TouchPhase};
-use bevy_math::Vec2;
 use bevy_render::camera::RenderTarget;
 use bevy_utils::{tracing::debug, HashMap, HashSet};
-use bevy_window::{PrimaryWindow, WindowRef};
+use bevy_window::{PrimaryWindow, WindowEvent, WindowRef};
 
 use crate::{
- events::PointerCancel,
- pointer::{InputMove, InputPress, Location, PointerButton, PointerId},
+ pointer::{Location, PointerAction, PointerButton, PointerId, PointerInput, PressDirection},
  PointerBundle,
 };
 
 /// Sends touch pointer events to be consumed by the core plugin
-///
-/// IMPORTANT: the commands must be flushed after this system is run because we need spawning to
-/// happen immediately to prevent issues with missed events needed for drag and drop.
 pub fn touch_pick_events(
  // Input
- mut touches: EventReader<TouchInput>,
+ mut window_events: EventReader<WindowEvent>,
  primary_window: Query<Entity, With<PrimaryWindow>>,
- // Local
- mut location_cache: Local<HashMap<u64, TouchInput>>,
+ // Locals
+ mut touch_cache: Local<HashMap<u64, TouchInput>>,
  // Output
  mut commands: Commands,
- mut input_moves: EventWriter<InputMove>,
- mut input_presses: EventWriter<InputPress>,
- mut cancel_events: EventWriter<PointerCancel>,
+ mut pointer_events: EventWriter<PointerInput>,
 ) {
- for touch in touches.read() {
- let pointer = PointerId::Touch(touch.id);
- let location = Location {
- target: match RenderTarget::Window(WindowRef::Entity(touch.window))
- .normalize(primary_window.get_single().ok())
- {
- Some(target) => target,
- None => continue,
- },
- position: touch.position,
- };
- match touch.phase {
- TouchPhase::Started => {
- debug!("Spawning pointer {:?}", pointer);
- commands.spawn((PointerBundle::new(pointer).with_location(location.clone()),));
+ for window_event in window_events.read() {
+ if let WindowEvent::TouchInput(touch) = window_event {
+ let pointer = PointerId::Touch(touch.id);
+ let location = Location {
+ target: match RenderTarget::Window(WindowRef::Entity(touch.window))
+ .normalize(primary_window.get_single().ok())
+ {
+ Some(target) => target,
+ None => continue,
+ },
+ position: touch.position,
+ };
+ match touch.phase {
+ TouchPhase::Started => {
+ debug!("Spawning pointer {:?}", pointer);
+ commands.spawn(PointerBundle::new(pointer).with_location(location.clone()));
 
- input_moves.send(InputMove::new(pointer, location, Vec2::ZERO));
- input_presses.send(InputPress::new_down(pointer, PointerButton::Primary));
- location_cache.insert(touch.id, *touch);
- }
- TouchPhase::Moved => {
- // Send a move event only if it isn't the same as the last one
- if let Some(last_touch) = location_cache.get(&touch.id) {
- if last_touch == touch {
- continue;
+ pointer_events.send(PointerInput::new(
+ pointer,
+ location,
+ PointerAction::Pressed {
+ direction: PressDirection::Down,
+ button: PointerButton::Primary,
+ },
+ ));
+
+ touch_cache.insert(touch.id, *touch);
+ }
+ TouchPhase::Moved => {
+ // Send a move event only if it isn't the same as the last one
+ if let Some(last_touch) = touch_cache.get(&touch.id) {
+ if last_touch == touch {
+ continue;
+ }
+ pointer_events.send(PointerInput::new(
+ pointer,
+ location,
+ PointerAction::Moved {
+ delta: touch.position - last_touch.position,
+ },
+ ));
  }
- input_moves.send(InputMove::new(
+ touch_cache.insert(touch.id, *touch);
+ }
+ TouchPhase::Ended => {
+ pointer_events.send(PointerInput::new(
  pointer,
  location,
- touch.position - last_touch.position,
+ PointerAction::Pressed {
+ direction: PressDirection::Up,
+ button: PointerButton::Primary,
+ },
  ));
+ touch_cache.remove(&touch.id);
+ }
+ TouchPhase::Canceled => {
+ pointer_events.send(PointerInput::new(
+ pointer,
+ location,
+ PointerAction::Canceled,
+ ));
+ touch_cache.remove(&touch.id);
  }
- location_cache.insert(touch.id, *touch);
- }
- TouchPhase::Ended | TouchPhase::Canceled => {
- input_presses.send(InputPress::new_up(pointer, PointerButton::Primary));
- location_cache.remove(&touch.id);
- cancel_events.send(PointerCancel {
- pointer_id: pointer,
- });
  }
  }
  }
@@ -86,15 +102,12 @@ pub fn deactivate_touch_pointers(
  mut touches: EventReader<TouchInput>,
 ) {
  for touch in touches.read() {
- match touch.phase {
- TouchPhase::Ended | TouchPhase::Canceled => {
- for (entity, pointer) in &pointers {
- if pointer.get_touch_id() == Some(touch.id) {
- despawn_list.insert((entity, *pointer));
- }
+ if let TouchPhase::Ended | TouchPhase::Canceled = touch.phase {
+ for (entity, pointer) in &pointers {
+ if pointer.get_touch_id() == Some(touch.id) {
+ despawn_list.insert((entity, *pointer));
  }
  }
- _ => {}
  }
  }
  // A hash set is used to prevent despawning the same entity twice.