Fill in docs

Author: cart

crates/bevy_app/src/app.rs

@@ -1339,16 +1339,18 @@ impl App {
     /// # };
     /// #
     /// # #[derive(EntityEvent)]
-    /// # struct Invite;
+    /// # struct Invite {
+    /// #    entity: Entity,
+    /// # }
     /// #
     /// # #[derive(Component)]
     /// # struct Friend;
     /// #
     ///
     /// app.add_observer(|event: On<Party>, friends: Query<Entity, With<Friend>>, mut commands: Commands| {
     ///     if event.friends_allowed {
-    ///         for friend in friends.iter() {
-    ///             commands.trigger_targets(Invite, friend);
+    ///         for entity in friends.iter() {
+    ///             commands.trigger(Invite { entity } );
     ///         }
     ///     }
     /// });

crates/bevy_core_widgets/src/core_button.rs

@@ -6,7 +6,6 @@ use bevy_ecs::system::In;
 use bevy_ecs::{
     component::Component,
     entity::Entity,
-    event::EntityEvent,
     observer::On,
     query::With,
     system::{Commands, Query},

crates/bevy_core_widgets/src/core_checkbox.rs

@@ -90,17 +90,19 @@ fn checkbox_on_pointer_click(
 ///
 /// fn setup(mut commands: Commands) {
 ///     // Create a checkbox
-///     let checkbox = commands.spawn((
+///     let entity = commands.spawn((
 ///         CoreCheckbox::default(),
 ///     )).id();
 ///
 ///     // Set to checked
-///     commands.trigger_targets(SetChecked(true), checkbox);
+///     commands.trigger(SetChecked { entity, checked: true});
 /// }
 /// ```
 #[derive(EntityEvent)]
 pub struct SetChecked {
+    /// The [`CoreCheckbox`] entity to set the "checked" state on.
     pub entity: Entity,
+    /// Sets the `checked` state to `true` or `false`.
     pub checked: bool,
 }
 
@@ -115,12 +117,12 @@ pub struct SetChecked {
 ///
 /// fn setup(mut commands: Commands) {
 ///     // Create a checkbox
-///     let checkbox = commands.spawn((
+///     let entity = commands.spawn((
 ///         CoreCheckbox::default(),
 ///     )).id();
 ///
 ///     // Set to checked
-///     commands.trigger_targets(ToggleChecked, checkbox);
+///     commands.trigger(ToggleChecked { entity });
 /// }
 /// ```
 #[derive(EntityEvent)]

crates/bevy_core_widgets/src/core_radio.rs

@@ -149,12 +149,12 @@ fn radio_group_on_button_click(
 ) {
     if let Ok(CoreRadioGroup { on_change }) = q_group.get(ev.entity) {
         // Starting with the original target, search upward for a radio button.
-        let radio_id = if q_radio.contains(ev.original_entity()) {
-            ev.original_entity()
+        let radio_id = if q_radio.contains(ev.original_event_target()) {
+            ev.original_event_target()
         } else {
             // Search ancestors for the first radio button
             let mut found_radio = None;
-            for ancestor in q_parents.iter_ancestors(ev.original_entity()) {
+            for ancestor in q_parents.iter_ancestors(ev.original_event_target()) {
                 if q_group.contains(ancestor) {
                     // We reached a radio group before finding a radio button, bail out
                     return;

crates/bevy_core_widgets/src/core_slider.rs

@@ -488,27 +488,34 @@ pub(crate) fn slider_on_insert_step(insert: On<Insert, SliderStep>, mut world: D
 /// # Example:
 ///
 /// ```
-/// use bevy_ecs::system::Commands;
-/// use bevy_core_widgets::{CoreSlider, SliderRange, SliderValue, SetSliderValue};
-///
+/// # use bevy_ecs::system::Commands;
+/// # use bevy_core_widgets::{CoreSlider, SliderRange, SliderValue, SetSliderValue, SliderValueChange};
 /// fn setup(mut commands: Commands) {
 ///     // Create a slider
-///     let slider = commands.spawn((
+///     let entity = commands.spawn((
 ///         CoreSlider::default(),
 ///         SliderValue(0.5),
 ///         SliderRange::new(0.0, 1.0),
 ///     )).id();
 ///
 ///     // Set to an absolute value
-///     commands.trigger_targets(SetSliderValue::Absolute(0.75), slider);
+///     commands.trigger(SetSliderValue {
+///         entity,
+///         change: SliderValueChange::Absolute(0.75),
+///     });
 ///
 ///     // Adjust relatively
-///     commands.trigger_targets(SetSliderValue::Relative(-0.25), slider);
+///     commands.trigger(SetSliderValue {
+///         entity,
+///         change: SliderValueChange::Relative(-0.25),
+///     });
 /// }
 /// ```
 #[derive(EntityEvent, Clone)]
 pub struct SetSliderValue {
+    /// The slider entity to change.
     pub entity: Entity,
+    /// The change to apply to the slider entity.
     pub change: SliderValueChange,
 }
 

crates/bevy_core_widgets/src/lib.rs

@@ -21,21 +21,15 @@ mod core_radio;
 mod core_scrollbar;
 mod core_slider;
 
-use bevy_app::{PluginGroup, PluginGroupBuilder};
+pub use callback::*;
+pub use core_button::*;
+pub use core_checkbox::*;
+pub use core_radio::*;
+pub use core_scrollbar::*;
+pub use core_slider::*;
 
+use bevy_app::{PluginGroup, PluginGroupBuilder};
 use bevy_ecs::entity::Entity;
-pub use callback::{Callback, Notify};
-pub use core_button::{CoreButton, CoreButtonPlugin};
-pub use core_checkbox::{CoreCheckbox, CoreCheckboxPlugin, SetChecked, ToggleChecked};
-pub use core_radio::{CoreRadio, CoreRadioGroup, CoreRadioGroupPlugin};
-pub use core_scrollbar::{
-    ControlOrientation, CoreScrollbar, CoreScrollbarDragState, CoreScrollbarPlugin,
-    CoreScrollbarThumb,
-};
-pub use core_slider::{
-    CoreSlider, CoreSliderDragState, CoreSliderPlugin, CoreSliderThumb, SetSliderValue,
-    SliderPrecision, SliderRange, SliderStep, SliderValue, TrackClick,
-};
 
 /// A plugin group that registers the observers for all of the core widgets. If you don't want to
 /// use all of the widgets, you can import the individual widget plugins instead.

crates/bevy_ecs/README.md

@@ -301,7 +301,7 @@ fn reader(mut reader: EventReader<Message>) {
 
 ### Observers
 
-Observers are systems that listen for a "trigger" of a specific `Event`:
+Observers are systems that watch for a "trigger" of a specific `Event`:
 
 ```rust
 use bevy_ecs::prelude::*;
@@ -317,8 +317,6 @@ world.add_observer(|event: On<Speak>| {
     println!("{}", event.message);
 });
 
-world.flush();
-
 world.trigger(Speak {
     message: "Hello!".to_string(),
 });
@@ -334,19 +332,19 @@ If the event is an `EntityEvent`, it can also be triggered to target specific en
 use bevy_ecs::prelude::*;
 
 #[derive(EntityEvent)]
-struct Explode;
+struct Explode {
+    entity: Entity,
+}
 
 let mut world = World::new();
 let entity = world.spawn_empty().id();
 
-world.add_observer(|event: On<Explode>, mut commands: Commands| {
-    println!("Entity {} goes BOOM!", event.entity());
-    commands.entity(event.entity()).despawn();
+world.add_observer(|explode: On<Explode>, mut commands: Commands| {
+    println!("Entity {} goes BOOM!", explode.entity);
+    commands.entity(explode.entity).despawn();
 });
 
-world.flush();
-
-world.trigger_targets(Explode, entity);
+world.trigger(Explode { entity });
 ```
 
 [bevy]: https://bevy.org/

crates/bevy_ecs/macros/src/component.rs

@@ -120,7 +120,7 @@ pub fn derive_entity_event(input: TokenStream) -> TokenStream {
         .into();
     }
 
-    let entity_field = match get_entity_event_field(&ast) {
+    let entity_field = match get_event_target_field(&ast) {
         Ok(value) => value,
         Err(err) => return err.into_compile_error().into(),
     };
@@ -143,21 +143,21 @@ pub fn derive_entity_event(input: TokenStream) -> TokenStream {
         }
 
         impl #impl_generics #bevy_ecs_path::event::EntityEvent for #struct_name #type_generics #where_clause {
-            fn entity(&self) -> #bevy_ecs_path::entity::Entity {
+            fn event_target(&self) -> #bevy_ecs_path::entity::Entity {
                 self.#entity_field
             }
 
-            fn entity_mut(&mut self) -> &mut #bevy_ecs_path::entity::Entity {
+            fn event_target_mut(&mut self) -> &mut #bevy_ecs_path::entity::Entity {
                 &mut self.#entity_field
             }
         }
 
     })
 }
 
-/// Returns the field with the `#[event_entity]` attribute, the only field if unnamed,
+/// Returns the field with the `#[event_target]` attribute, the only field if unnamed,
 /// or the field with the name "entity".
-fn get_entity_event_field(ast: &DeriveInput) -> Result<Member> {
+fn get_event_target_field(ast: &DeriveInput) -> Result<Member> {
     let Data::Struct(DataStruct { fields, .. }) = &ast.data else {
         return Err(syn::Error::new(
             ast.span(),
@@ -169,29 +169,29 @@ fn get_entity_event_field(ast: &DeriveInput) -> Result<Member> {
             if field.ident.as_ref().is_some_and(|i| i == "entity") || field
                 .attrs
                 .iter()
-                .any(|attr| attr.path().is_ident(EVENT_ENTITY)) {
+                .any(|attr| attr.path().is_ident(EVENT_TARGET)) {
                     Some(Member::Named(field.ident.clone()?))
                 } else {
                     None
                 }
         }).ok_or(syn::Error::new(
             fields.span(),
-            "EntityEvent derive expected a field name 'entity' or a field annotated with #[event_entity]."
+            "EntityEvent derive expected a field name 'entity' or a field annotated with #[event_target]."
         )),
         Fields::Unnamed(fields) if fields.unnamed.len() == 1 => Ok(Member::Unnamed(Index::from(0))),
         Fields::Unnamed(fields) => fields.unnamed.iter().enumerate().find_map(|(index, field)| {
                 if field
                     .attrs
                     .iter()
-                    .any(|attr| attr.path().is_ident(EVENT_ENTITY)) {
+                    .any(|attr| attr.path().is_ident(EVENT_TARGET)) {
                         Some(Member::Unnamed(Index::from(index)))
                     } else {
                         None
                     }
             })
             .ok_or(syn::Error::new(
                 fields.span(),
-                "EntityEvent derive expected unnamed structs with one field or with a field annotated with #[event_entity].",
+                "EntityEvent derive expected unnamed structs with one field or with a field annotated with #[event_target].",
             )),
         Fields::Unit => Err(syn::Error::new(
             fields.span(),
@@ -536,7 +536,7 @@ pub const STORAGE: &str = "storage";
 pub const REQUIRE: &str = "require";
 pub const RELATIONSHIP: &str = "relationship";
 pub const RELATIONSHIP_TARGET: &str = "relationship_target";
-pub const EVENT_ENTITY: &str = "event_entity";
+pub const EVENT_TARGET: &str = "event_target";
 
 pub const ON_ADD: &str = "on_add";
 pub const ON_INSERT: &str = "on_insert";

crates/bevy_ecs/macros/src/lib.rs

@@ -566,7 +566,7 @@ pub fn derive_event(input: TokenStream) -> TokenStream {
 /// #[entity_event(auto_propagate)]
 /// struct MyEvent;
 /// ```
-#[proc_macro_derive(EntityEvent, attributes(entity_event, event_entity))]
+#[proc_macro_derive(EntityEvent, attributes(entity_event, event_target))]
 pub fn derive_entity_event(input: TokenStream) -> TokenStream {
     component::derive_entity_event(input)
 }

crates/bevy_ecs/src/component/tick.rs

@@ -86,7 +86,7 @@ impl Tick {
     }
 }
 
-/// An observer [`Event`] that can be used to maintain [`Tick`]s in custom data structures, enabling to make
+/// An [`Event`] that can be used to maintain [`Tick`]s in custom data structures, enabling to make
 /// use of bevy's periodic checks that clamps ticks to a certain range, preventing overflows and thus
 /// keeping methods like [`Tick::is_newer_than`] reliably return `false` for ticks that got too old.
 ///