Add event for clicks

crates/bevy_ui/src/focus.rs

@@ -3,7 +3,8 @@ use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
-    prelude::{Component, With},
+    event::EventWriter,
+    prelude::{Changed, Component, Event, With},
     query::WorldQuery,
     reflect::ReflectComponent,
     system::{Local, Query, Res},
@@ -55,6 +56,22 @@ impl Default for Interaction {
     }
 }
 
+/// Holds the last interaction that occurred for a UI node.
+///
+/// This is commonly used by adding `LastInteraction` as a member variable
+/// to a UI node such that `Click` events are sent on click/press-release action.
+#[derive(Component, Default, Debug, Clone)]
+pub struct LastInteraction(Interaction);
+
+/// Used to publish which entity was clicked
+///
+/// Commonly used by creating a UI node that contains `LastInteraction` as a member
+/// and then using `EventReader<Click>` to obtain the list of clicked UI nodes.
+///
+/// Note click captures the full click/press-release action.
+#[derive(Event)]
+pub struct Click(pub Entity);
+
 /// A component storing the position of the mouse relative to the node, (0., 0.) being the top-left corner and (1., 1.) being the bottom-right
 /// If the mouse is not over the node, the value will go beyond the range of (0., 0.) to (1., 1.)
 /// A None value means that the cursor position is unknown.
@@ -296,3 +313,21 @@ pub fn ui_focus_system(
         }
     }
 }
+
+/// The system that sends a click event to publish which entities where clicked
+/// for all UI nodes that contain the `LastInteraction` `Component`
+///
+/// Included by default with `UiPlugin`.
+pub fn ui_click(
+    mut click_events: EventWriter<Click>,
+    mut buttons: Query<(Entity, &Interaction, &mut LastInteraction), Changed<Interaction>>,
+) {
+    for (entity, &interaction, mut last_interaction) in &mut buttons {
+        // Publish a click event for every entity that has changed in one cycle from
+        // `Interaction::Hovered` to `Interaction::Pressed`
+        if interaction == Interaction::Hovered && last_interaction.0 == Interaction::Pressed {
+            click_events.send(Click(entity));
+        }
+        last_interaction.0 = interaction;
+    }
+}

crates/bevy_ui/src/lib.rs

@@ -35,7 +35,7 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, widget::Label,
-        Interaction, UiScale,
+        Click, Interaction, LastInteraction, UiScale,
     };
 }
 
@@ -120,9 +120,14 @@ impl Plugin for UiPlugin {
             .register_type::<widget::Button>()
             .register_type::<widget::Label>()
             .register_type::<ZIndex>()
+            .add_event::<Click>()
             .add_systems(
                 PreUpdate,
-                ui_focus_system.in_set(UiSystem::Focus).after(InputSystem),
+                (
+                    ui_focus_system.in_set(UiSystem::Focus).after(InputSystem),
+                    ui_click,
+                )
+                    .chain(),
             );
         // add these systems to front because these must run before transform update systems
         #[cfg(feature = "bevy_text")]

crates/bevy_ui/src/node_bundles.rs

@@ -4,8 +4,8 @@
 use crate::widget::TextFlags;
 use crate::{
     widget::{Button, UiImageSize},
-    BackgroundColor, BorderColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage,
-    UiTextureAtlasImage, ZIndex,
+    BackgroundColor, BorderColor, ContentSize, FocusPolicy, Interaction, LastInteraction, Node,
+    Style, UiImage, UiTextureAtlasImage, ZIndex,
 };
 use bevy_asset::Handle;
 use bevy_ecs::bundle::Bundle;
@@ -305,6 +305,8 @@ pub struct ButtonBundle {
     pub computed_visibility: ComputedVisibility,
     /// Indicates the depth at which the node should appear in the UI
     pub z_index: ZIndex,
+    /// Holds the previous Interation
+    pub last_interaction: LastInteraction,
 }
 
 impl Default for ButtonBundle {
@@ -323,6 +325,7 @@ impl Default for ButtonBundle {
             visibility: Default::default(),
             computed_visibility: Default::default(),
             z_index: Default::default(),
+            last_interaction: Default::default(),
         }
     }
 }

examples/ecs/state.rs

@@ -18,7 +18,13 @@ fn main() {
         .add_systems(OnEnter(AppState::Menu), setup_menu)
         // By contrast, update systems are stored in the `Update` schedule. They simply
         // check the value of the `State<T>` resource to see if they should run each frame.
-        .add_systems(Update, menu.run_if(in_state(AppState::Menu)))
+        .add_systems(
+            Update,
+            (
+                menu_interaction.run_if(in_state(AppState::Menu)),
+                menu_action.run_if(on_event::<Click>()),
+            ),
+        )
         .add_systems(OnExit(AppState::Menu), cleanup_menu)
         .add_systems(OnEnter(AppState::InGame), setup_game)
         .add_systems(
@@ -90,8 +96,7 @@ fn setup_menu(mut commands: Commands) {
     commands.insert_resource(MenuData { button_entity });
 }
 
-fn menu(
-    mut next_state: ResMut<NextState<AppState>>,
+fn menu_interaction(
     mut interaction_query: Query<
         (&Interaction, &mut BackgroundColor),
         (Changed<Interaction>, With<Button>),
@@ -101,7 +106,6 @@ fn menu(
         match *interaction {
             Interaction::Pressed => {
                 *color = PRESSED_BUTTON.into();
-                next_state.set(AppState::InGame);
             }
             Interaction::Hovered => {
                 *color = HOVERED_BUTTON.into();
@@ -113,6 +117,10 @@ fn menu(
     }
 }
 
+fn menu_action(mut next_state: ResMut<NextState<AppState>>) {
+    next_state.set(AppState::InGame);
+}
+
 fn cleanup_menu(mut commands: Commands, menu_data: Res<MenuData>) {
     commands.entity(menu_data.button_entity).despawn_recursive();
 }

examples/games/game_menu.rs

@@ -780,17 +780,15 @@ mod menu {
     }
 
     fn menu_action(
-        interaction_query: Query<
-            (&Interaction, &MenuButtonAction),
-            (Changed<Interaction>, With<Button>),
-        >,
+        mut click_events: EventReader<Click>,
+        menu_buttons: Query<&MenuButtonAction>,
         mut app_exit_events: EventWriter<AppExit>,
         mut menu_state: ResMut<NextState<MenuState>>,
         mut game_state: ResMut<NextState<GameState>>,
     ) {
-        for (interaction, menu_button_action) in &interaction_query {
-            if *interaction == Interaction::Pressed {
-                match menu_button_action {
+        for event in &mut click_events {
+            if let Ok(menu_button) = menu_buttons.get(event.0) {
+                match menu_button {
                     MenuButtonAction::Quit => app_exit_events.send(AppExit),
                     MenuButtonAction::Play => {
                         game_state.set(GameState::Game);