forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Renamed EventWriter::send methods to write. (#17977)

Browse Source 
Fixes #17856.

## Migration Guide
- `EventWriter::send` has been renamed to `EventWriter::write`.
- `EventWriter::send_batch` has been renamed to
`EventWriter::write_batch`.
- `EventWriter::send_default` has been renamed to
`EventWriter::write_default`.

---------

Co-authored-by: François Mockers <mockersf@gmail.com>
This commit is contained in:
AlephCubed 2025-02-23 13:18:52 -08:00 committed by GitHub
parent dba1f7a7b6
commit 5f86668bbb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
41 changed files with 150 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/bevy_app/src/app.rs
View File

@ -1713,9 +1713,9 @@ mod tests {
fn raise_exits(mut exits: EventWriter<AppExit>) {
// Exit codes chosen by a fair dice roll.
// Unlikely to overlap with default values.
exits.send(AppExit::Success);
exits.send(AppExit::from_code(4));
exits.send(AppExit::from_code(73));
exits.write(AppExit::Success);
exits.write(AppExit::from_code(4));
exits.write(AppExit::from_code(73));
}
let exit = App::new().add_systems(Update, raise_exits).run();

2
crates/bevy_app/src/terminal_ctrl_c_handler.rs
View File

@ -50,7 +50,7 @@ impl TerminalCtrlCHandlerPlugin {
/// Sends a [`AppExit`] event when the user presses `Ctrl+C` on the terminal.
pub fn exit_on_flag(mut events: EventWriter<AppExit>) {
if SHOULD_EXIT.load(Ordering::Relaxed) {
events.send(AppExit::from_code(130));
events.write(AppExit::from_code(130));
}
}
}

2
crates/bevy_asset/src/asset_changed.rs
View File

@ -330,7 +330,7 @@ mod tests {
_query: Query<&mut MyComponent, AssetChanged<MyComponent>>,
mut exit: EventWriter<AppExit>,
) {
exit.send(AppExit::Error(NonZero::<u8>::MIN));
exit.write(AppExit::Error(NonZero::<u8>::MIN));
}
run_app(compatible_filter);
}

2
crates/bevy_asset/src/assets.rs
View File

@ -579,7 +579,7 @@ impl<A: Asset> Assets<A> {
};
}
}
events.send_batch(assets.queued_events.drain(..));
events.write_batch(assets.queued_events.drain(..));
}
/// A run condition for [`asset_events`]. The system will not run if there are no events to

2
crates/bevy_ecs/examples/events.rs
View File

@ -45,7 +45,7 @@ struct MyEvent {
fn sending_system(mut event_writer: EventWriter<MyEvent>) {
let random_value: f32 = rand::random();
if random_value > 0.5 {
event_writer.send(MyEvent {
event_writer.write(MyEvent {
message: "A random event with value > 0.5".to_string(),
random_value,
});

2
crates/bevy_ecs/src/change_detection.rs
View File

@ -223,7 +223,7 @@ pub trait DetectChangesMut: DetectChanges {
/// let new_score = 0;
/// if let Some(Score(previous_score)) = score.replace_if_neq(Score(new_score)) {
/// // If `score` change, emit a `ScoreChanged` event.
/// score_changed.send(ScoreChanged {
/// score_changed.write(ScoreChanged {
/// current: new_score,
/// previous: previous_score,
/// });

49
crates/bevy_ecs/src/event/writer.rs
View File

@ -14,14 +14,14 @@ use bevy_ecs::{
/// #[derive(Event)]
/// pub struct MyEvent; // Custom event type.
/// fn my_system(mut writer: EventWriter<MyEvent>) {
/// writer.send(MyEvent);
/// writer.write(MyEvent);
/// }
///
/// # bevy_ecs::system::assert_is_system(my_system);
/// ```
/// # Observers
///
/// "Buffered" Events, such as those sent directly in [`Events`] or sent using [`EventWriter`], do _not_ automatically
/// "Buffered" Events, such as those sent directly in [`Events`] or written using [`EventWriter`], do _not_ automatically
/// trigger any [`Observer`]s watching for that event, as each [`Event`] has different requirements regarding _if_ it will
/// be triggered, and if so, _when_ it will be triggered in the schedule.
///
@ -32,7 +32,7 @@ use bevy_ecs::{
///
/// # Untyped events
///
/// `EventWriter` can only send events of one specific type, which must be known at compile-time.
/// `EventWriter` can only write events of one specific type, which must be known at compile-time.
/// This is not a problem most of the time, but you may find a situation where you cannot know
/// ahead of time every kind of event you'll need to send. In this case, you can use the "type-erased event" pattern.
///
@ -64,13 +64,48 @@ pub struct EventWriter<'w, E: Event> {
}
impl<'w, E: Event> EventWriter<'w, E> {
/// Writes an `event`, which can later be read by [`EventReader`](super::EventReader)s.
/// This method returns the [ID](`EventId`) of the written `event`.
///
/// See [`Events`] for details.
#[doc(alias = "send")]
#[track_caller]
pub fn write(&mut self, event: E) -> EventId<E> {
self.events.send(event)
}
/// Sends a list of `events` all at once, which can later be read by [`EventReader`](super::EventReader)s.
/// This is more efficient than sending each event individually.
/// This method returns the [IDs](`EventId`) of the written `events`.
///
/// See [`Events`] for details.
#[doc(alias = "send_batch")]
#[track_caller]
pub fn write_batch(&mut self, events: impl IntoIterator<Item = E>) -> SendBatchIds<E> {
self.events.send_batch(events)
}
/// Writes the default value of the event. Useful when the event is an empty struct.
/// This method returns the [ID](`EventId`) of the written `event`.
///
/// See [`Events`] for details.
#[doc(alias = "send_default")]
#[track_caller]
pub fn write_default(&mut self) -> EventId<E>
where
E: Default,
{
self.events.send_default()
}
/// Sends an `event`, which can later be read by [`EventReader`](super::EventReader)s.
/// This method returns the [ID](`EventId`) of the sent `event`.
///
/// See [`Events`] for details.
#[deprecated(since = "0.16.0", note = "Use `EventWriter::write` instead.")]
#[track_caller]
pub fn send(&mut self, event: E) -> EventId<E> {
self.events.send(event)
self.write(event)
}
/// Sends a list of `events` all at once, which can later be read by [`EventReader`](super::EventReader)s.
@ -78,20 +113,22 @@ impl<'w, E: Event> EventWriter<'w, E> {
/// This method returns the [IDs](`EventId`) of the sent `events`.
///
/// See [`Events`] for details.
#[deprecated(since = "0.16.0", note = "Use `EventWriter::write_batch` instead.")]
#[track_caller]
pub fn send_batch(&mut self, events: impl IntoIterator<Item = E>) -> SendBatchIds<E> {
self.events.send_batch(events)
self.write_batch(events)
}
/// Sends the default value of the event. Useful when the event is an empty struct.
/// This method returns the [ID](`EventId`) of the sent `event`.
///
/// See [`Events`] for details.
#[deprecated(since = "0.16.0", note = "Use `EventWriter::write_default` instead.")]
#[track_caller]
pub fn send_default(&mut self) -> EventId<E>
where
E: Default,
{
self.events.send_default()
self.write_default()
}
}

2
crates/bevy_ecs/src/system/system_param.rs
View File

@ -685,7 +685,7 @@ unsafe impl<'w, 's, D: ReadOnlyQueryData + 'static, F: QueryFilter + 'static> Re
/// // ...
/// # let _event = event;
/// }
/// set.p1().send(MyEvent::new());
/// set.p1().write(MyEvent::new());
///
/// let entities = set.p2().entities();
/// // ...

18
crates/bevy_gilrs/src/gilrs_system.rs
View File

@ -26,7 +26,7 @@ pub fn gilrs_event_startup_system(
gamepads.id_to_entity.insert(id, entity);
gamepads.entity_to_id.insert(entity, id);
events.send(GamepadConnectionEvent {
events.write(GamepadConnectionEvent {
gamepad: entity,
connection: GamepadConnection::Connected {
name: gamepad.name().to_string(),
@ -69,8 +69,8 @@ pub fn gilrs_event_system(
},
);
events.send(event.clone().into());
connection_events.send(event);
events.write(event.clone().into());
connection_events.write(event);
}
EventType::Disconnected => {
let gamepad = gamepads
@ -79,8 +79,8 @@ pub fn gilrs_event_system(
.copied()
.expect("mapping should exist from connection");
let event = GamepadConnectionEvent::new(gamepad, GamepadConnection::Disconnected);
events.send(event.clone().into());
connection_events.send(event);
events.write(event.clone().into());
connection_events.write(event);
}
EventType::ButtonChanged(gilrs_button, raw_value, _) => {
let Some(button) = convert_button(gilrs_button) else {
@ -91,8 +91,8 @@ pub fn gilrs_event_system(
.get(&gilrs_event.id)
.copied()
.expect("mapping should exist from connection");
events.send(RawGamepadButtonChangedEvent::new(gamepad, button, raw_value).into());
button_events.send(RawGamepadButtonChangedEvent::new(
events.write(RawGamepadButtonChangedEvent::new(gamepad, button, raw_value).into());
button_events.write(RawGamepadButtonChangedEvent::new(
gamepad, button, raw_value,
));
}
@ -105,8 +105,8 @@ pub fn gilrs_event_system(
.get(&gilrs_event.id)
.copied()
.expect("mapping should exist from connection");
events.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value).into());
axis_event.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value));
events.write(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value).into());
axis_event.write(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value));
}
_ => (),
};

16
crates/bevy_input/src/gamepad.rs
View File

@ -1539,7 +1539,7 @@ pub fn gamepad_event_processing_system(
match event {
// Connections require inserting/removing components so they are done in a separate system
RawGamepadEvent::Connection(send_event) => {
processed_events.send(GamepadEvent::from(send_event.clone()));
processed_events.write(GamepadEvent::from(send_event.clone()));
}
RawGamepadEvent::Axis(RawGamepadAxisChangedEvent {
gamepad,
@ -1559,8 +1559,8 @@ pub fn gamepad_event_processing_system(
gamepad_axis.analog.set(axis, filtered_value.raw);
let send_event =
GamepadAxisChangedEvent::new(gamepad, axis, filtered_value.scaled.to_f32());
processed_axis_events.send(send_event);
processed_events.send(GamepadEvent::from(send_event));
processed_axis_events.write(send_event);
processed_events.write(GamepadEvent::from(send_event));
}
RawGamepadEvent::Button(RawGamepadButtonChangedEvent {
gamepad,
@ -1583,7 +1583,7 @@ pub fn gamepad_event_processing_system(
if button_settings.is_released(filtered_value.raw) {
// Check if button was previously pressed
if gamepad_buttons.pressed(button) {
processed_digital_events.send(GamepadButtonStateChangedEvent::new(
processed_digital_events.write(GamepadButtonStateChangedEvent::new(
gamepad,
button,
ButtonState::Released,
@ -1595,7 +1595,7 @@ pub fn gamepad_event_processing_system(
} else if button_settings.is_pressed(filtered_value.raw) {
// Check if button was previously not pressed
if !gamepad_buttons.pressed(button) {
processed_digital_events.send(GamepadButtonStateChangedEvent::new(
processed_digital_events.write(GamepadButtonStateChangedEvent::new(
gamepad,
button,
ButtonState::Pressed,
@ -1615,8 +1615,8 @@ pub fn gamepad_event_processing_system(
button_state,
filtered_value.scaled.to_f32(),
);
processed_analog_events.send(send_event);
processed_events.send(GamepadEvent::from(send_event));
processed_analog_events.write(send_event);
processed_events.write(GamepadEvent::from(send_event));
}
}
}
@ -1699,7 +1699,7 @@ impl GamepadRumbleIntensity {
/// gamepads: Query<Entity, With<Gamepad>>,
/// ) {
/// for entity in gamepads.iter() {
/// rumble_requests.send(GamepadRumbleRequest::Add {
/// rumble_requests.write(GamepadRumbleRequest::Add {
/// gamepad: entity,
/// intensity: GamepadRumbleIntensity::MAX,
/// duration: Duration::from_secs_f32(0.5),

32
crates/bevy_picking/src/events.rs
View File

@ -464,7 +464,7 @@ pub fn pointer_events(
Out { hit: hit.clone() },
);
commands.trigger_targets(out_event.clone(), hovered_entity);
event_writers.out_events.send(out_event);
event_writers.out_events.write(out_event);
// Possibly send DragLeave events
for button in PointerButton::iter() {
@ -482,7 +482,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_leave_event.clone(), hovered_entity);
event_writers.drag_leave_events.send(drag_leave_event);
event_writers.drag_leave_events.write(drag_leave_event);
}
}
}
@ -528,7 +528,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_enter_event.clone(), hovered_entity);
event_writers.drag_enter_events.send(drag_enter_event);
event_writers.drag_enter_events.write(drag_enter_event);
}
}
@ -540,7 +540,7 @@ pub fn pointer_events(
Over { hit: hit.clone() },
);
commands.trigger_targets(over_event.clone(), hovered_entity);
event_writers.over_events.send(over_event);
event_writers.over_events.write(over_event);
}
}
@ -571,7 +571,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(pressed_event.clone(), hovered_entity);
event_writers.pressed_events.send(pressed_event);
event_writers.pressed_events.write(pressed_event);
// Also insert the press into the state
state
.pressing
@ -600,7 +600,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(click_event.clone(), hovered_entity);
event_writers.click_events.send(click_event);
event_writers.click_events.write(click_event);
}
// Always send the Released event
let released_event = Pointer::new(
@ -613,7 +613,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(released_event.clone(), hovered_entity);
event_writers.released_events.send(released_event);
event_writers.released_events.write(released_event);
}
// Then emit the drop events.
@ -631,7 +631,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_drop_event.clone(), *dragged_over);
event_writers.drag_drop_events.send(drag_drop_event);
event_writers.drag_drop_events.write(drag_drop_event);
}
// Emit DragEnd
let drag_end_event = Pointer::new(
@ -644,7 +644,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_end_event.clone(), drag_target);
event_writers.drag_end_events.send(drag_end_event);
event_writers.drag_end_events.write(drag_end_event);
// Emit DragLeave
for (dragged_over, hit) in state.dragging_over.iter() {
let drag_leave_event = Pointer::new(
@ -658,7 +658,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_leave_event.clone(), *dragged_over);
event_writers.drag_leave_events.send(drag_leave_event);
event_writers.drag_leave_events.write(drag_leave_event);
}
}
@ -698,7 +698,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_start_event.clone(), *press_target);
event_writers.drag_start_events.send(drag_start_event);
event_writers.drag_start_events.write(drag_start_event);
}
// Emit Drag events to the entities we are dragging
@ -718,7 +718,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_event.clone(), *drag_target);
event_writers.drag_events.send(drag_event);
event_writers.drag_events.write(drag_event);
// Update drag position
drag.latest_pos = location.position;
@ -741,7 +741,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(drag_over_event.clone(), hovered_entity);
event_writers.drag_over_events.send(drag_over_event);
event_writers.drag_over_events.write(drag_over_event);
}
}
}
@ -762,7 +762,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(move_event.clone(), hovered_entity);
event_writers.move_events.send(move_event);
event_writers.move_events.write(move_event);
}
}
PointerAction::Scroll { x, y, unit } => {
@ -784,7 +784,7 @@ pub fn pointer_events(
},
);
commands.trigger_targets(scroll_event.clone(), hovered_entity);
event_writers.scroll_events.send(scroll_event);
event_writers.scroll_events.write(scroll_event);
}
}
// Canceled
@ -798,7 +798,7 @@ pub fn pointer_events(
let cancel_event =
Pointer::new(pointer_id, location.clone(), hovered_entity, Cancel { hit });
commands.trigger_targets(cancel_event.clone(), hovered_entity);
event_writers.cancel_events.send(cancel_event);
event_writers.cancel_events.write(cancel_event);
}
// Clear the state for the canceled pointer
pointer_state.clear(pointer_id);

14
crates/bevy_picking/src/input.rs
View File

@ -125,7 +125,7 @@ pub fn mouse_pick_events(
},
position: event.position,
};
pointer_events.send(PointerInput::new(
pointer_events.write(PointerInput::new(
PointerId::Mouse,
location,
PointerAction::Move {
@ -155,7 +155,7 @@ pub fn mouse_pick_events(
ButtonState::Pressed => PointerAction::Press(button),
ButtonState::Released => PointerAction::Release(button),
};
pointer_events.send(PointerInput::new(PointerId::Mouse, location, action));
pointer_events.write(PointerInput::new(PointerId::Mouse, location, action));
}
WindowEvent::MouseWheel(event) => {
let MouseWheel { unit, x, y, window } = *event;
@ -172,7 +172,7 @@ pub fn mouse_pick_events(
let action = PointerAction::Scroll { x, y, unit };
pointer_events.send(PointerInput::new(PointerId::Mouse, location, action));
pointer_events.write(PointerInput::new(PointerId::Mouse, location, action));
}
_ => {}
}
@ -207,7 +207,7 @@ pub fn touch_pick_events(
debug!("Spawning pointer {:?}", pointer);
commands.spawn((pointer, PointerLocation::new(location.clone())));
pointer_events.send(PointerInput::new(
pointer_events.write(PointerInput::new(
pointer,
location,
PointerAction::Press(PointerButton::Primary),
@ -221,7 +221,7 @@ pub fn touch_pick_events(
if last_touch == touch {
continue;
}
pointer_events.send(PointerInput::new(
pointer_events.write(PointerInput::new(
pointer,
location,
PointerAction::Move {
@ -232,7 +232,7 @@ pub fn touch_pick_events(
touch_cache.insert(touch.id, *touch);
}
TouchPhase::Ended => {
pointer_events.send(PointerInput::new(
pointer_events.write(PointerInput::new(
pointer,
location,
PointerAction::Release(PointerButton::Primary),
@ -240,7 +240,7 @@ pub fn touch_pick_events(
touch_cache.remove(&touch.id);
}
TouchPhase::Canceled => {
pointer_events.send(PointerInput::new(
pointer_events.write(PointerInput::new(
pointer,
location,
PointerAction::Cancel,

2
crates/bevy_picking/src/lib.rs
View File

@ -64,7 +64,7 @@
//! commands.entity(trigger.target()).despawn();
//! })
//! .observe(|trigger: Trigger<Pointer<Over>>, mut events: EventWriter<Greeting>| {
//! events.send(Greeting);
//! events.write(Greeting);
//! });
//! }
//! ```

2
crates/bevy_picking/src/mesh_picking/mod.rs
View File

@ -128,7 +128,7 @@ pub fn update_hits(
.collect::<Vec<_>>();
let order = camera.order as f32;
if !picks.is_empty() {
output.send(PointerHits::new(ray_id.pointer, picks, order));
output.write(PointerHits::new(ray_id.pointer, picks, order));
}
}
}

2
crates/bevy_picking/src/window.rs
View File

@ -39,7 +39,7 @@ pub fn update_window_hits(
{
let entity = window_ref.entity();
let hit_data = HitData::new(entity, 0.0, None, None);
output_events.send(PointerHits::new(
output_events.write(PointerHits::new(
*pointer_id,
vec![(entity, hit_data)],
f32::NEG_INFINITY,

2
crates/bevy_sprite/src/picking_backend.rs
View File

@ -246,6 +246,6 @@ fn sprite_picking(
.collect();
let order = camera.order as f32;
output.send(PointerHits::new(*pointer, picks, order));
output.write(PointerHits::new(*pointer, picks, order));
}
}

6
crates/bevy_state/src/state/transitions.rs
View File

@ -145,7 +145,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
// Transition events are sent even for same state transitions
// Although enter and exit schedules are not run by default.
event.send(StateTransitionEvent {
event.write(StateTransitionEvent {
exited: Some(exited.clone()),
entered: Some(entered.clone()),
});
@ -154,7 +154,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
// If the [`State<S>`] resource does not exist, we create it, compute dependent states, send a transition event and register the `OnEnter` schedule.
commands.insert_resource(State(entered.clone()));
event.send(StateTransitionEvent {
event.write(StateTransitionEvent {
exited: None,
entered: Some(entered.clone()),
});
@ -166,7 +166,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
if let Some(resource) = current_state {
commands.remove_resource::<State<S>>();
event.send(StateTransitionEvent {
event.write(StateTransitionEvent {
exited: Some(resource.get().clone()),
entered: None,
});

4
crates/bevy_time/src/lib.rs
View File

@ -294,13 +294,13 @@ mod tests {
.add_event::<TestEvent<i32>>()
.add_event::<TestEvent<()>>()
.add_systems(Startup, move |mut ev2: EventWriter<TestEvent<()>>| {
ev2.send(TestEvent {
ev2.write(TestEvent {
sender: tx2.clone(),
});
})
.add_systems(Update, move |mut ev1: EventWriter<TestEvent<i32>>| {
// Keep adding events so this event type is processed every update
ev1.send(TestEvent {
ev1.write(TestEvent {
sender: tx1.clone(),
});
})

2
crates/bevy_ui/src/picking_backend.rs
View File

@ -212,6 +212,6 @@ pub fn ui_picking(
.unwrap_or_default() as f32
+ 0.5; // bevy ui can run on any camera, it's a special case
output.send(PointerHits::new(*pointer, picks, order));
output.write(PointerHits::new(*pointer, picks, order));
}
}

4
crates/bevy_window/src/system.rs
View File

@ -13,7 +13,7 @@ use bevy_ecs::prelude::*;
pub fn exit_on_all_closed(mut app_exit_events: EventWriter<AppExit>, windows: Query<&Window>) {
if windows.is_empty() {
log::info!("No windows are open, exiting");
app_exit_events.send(AppExit::Success);
app_exit_events.write(AppExit::Success);
}
}
@ -28,7 +28,7 @@ pub fn exit_on_primary_closed(
) {
if windows.is_empty() {
log::info!("Primary window was closed, exiting");
app_exit_events.send(AppExit::Success);
app_exit_events.write(AppExit::Success);
}
}

2
crates/bevy_winit/src/accessibility.rs
View File

@ -159,7 +159,7 @@ fn poll_receivers(
for (_id, handler) in handlers.iter() {
let mut handler = handler.lock().unwrap();
while let Some(event) = handler.pop_front() {
actions.send(ActionRequestWrapper(event));
actions.write(ActionRequestWrapper(event));
}
}
}

6
crates/bevy_winit/src/state.rs
View File

@ -912,7 +912,7 @@ pub(crate) fn react_to_resize(
.resolution
.set_physical_resolution(size.width, size.height);
window_resized.send(WindowResized {
window_resized.write(WindowResized {
window: window_entity,
width: window.width(),
height: window.height(),
@ -928,7 +928,7 @@ pub(crate) fn react_to_scale_factor_change(
) {
window.resolution.set_scale_factor(scale_factor as f32);
window_backend_scale_factor_changed.send(WindowBackendScaleFactorChanged {
window_backend_scale_factor_changed.write(WindowBackendScaleFactorChanged {
window: window_entity,
scale_factor,
});
@ -937,7 +937,7 @@ pub(crate) fn react_to_scale_factor_change(
let scale_factor_override = window.resolution.scale_factor_override();
if scale_factor_override.is_none() && !relative_eq!(scale_factor as f32, prior_factor) {
window_scale_factor_changed.send(WindowScaleFactorChanged {
window_scale_factor_changed.write(WindowScaleFactorChanged {
window: window_entity,
scale_factor,
});

10
crates/bevy_winit/src/system.rs
View File

@ -115,7 +115,7 @@ pub fn create_windows<F: QueryFilter + 'static>(
}
}
window_created_events.send(WindowCreated { window: entity });
window_created_events.write(WindowCreated { window: entity });
}
}
@ -135,7 +135,7 @@ pub(crate) fn check_keyboard_focus_lost(
}
}
if focus_lost & !focus_gained {
keyboard_focus.send(KeyboardFocusLost);
keyboard_focus.write(KeyboardFocusLost);
}
}
@ -215,7 +215,7 @@ pub(crate) fn despawn_windows(
// Drop all the windows that are waiting to be closed
windows_to_drop.clear();
for window in closing.iter() {
closing_events.send(WindowClosing { window });
closing_events.write(WindowClosing { window });
}
for window in closed.read() {
info!("Closing window {}", window);
@ -230,7 +230,7 @@ pub(crate) fn despawn_windows(
// Keeping the wrapper and dropping it next frame in this system ensure its dropped in the main thread
windows_to_drop.push(window);
}
closed_events.send(WindowClosed { window });
closed_events.write(WindowClosed { window });
}
}
@ -239,7 +239,7 @@ pub(crate) fn despawn_windows(
if !exit_events.is_empty() {
exit_events.clear();
for window in window_entities.iter() {
closing_events.send(WindowClosing { window });
closing_events.write(WindowClosing { window });
}
}
}

4
examples/3d/mixed_lighting.rs
View File

@ -175,7 +175,7 @@ fn spawn_scene(commands: &mut Commands, asset_server: &AssetServer) {
mut lighting_mode_change_event_writer: EventWriter<LightingModeChanged>| {
// When the scene loads, send a `LightingModeChanged` event so
// that we set up the lightmaps.
lighting_mode_change_event_writer.send(LightingModeChanged);
lighting_mode_change_event_writer.write(LightingModeChanged);
},
);
}
@ -393,7 +393,7 @@ fn handle_lighting_mode_change(
) {
for event in widget_click_event_reader.read() {
app_status.lighting_mode = **event;
lighting_mode_change_event_writer.send(LightingModeChanged);
lighting_mode_change_event_writer.write(LightingModeChanged);
}
}

2
examples/app/custom_loop.rs
View File

@ -35,7 +35,7 @@ fn print_system(input: Res<Input>) {
fn exit_system(input: Res<Input>, mut exit_event: EventWriter<AppExit>) {
if input.0 == "exit" {
exit_event.send(AppExit::Success);
exit_event.write(AppExit::Success);
}
}

2
examples/app/headless_renderer.rs
View File

@ -535,7 +535,7 @@ fn update(
};
}
if scene_controller.single_image {
app_exit_writer.send(AppExit::Success);
app_exit_writer.write(AppExit::Success);
}
}
} else {

2
examples/app/log_layers_ecs.rs
View File

@ -54,7 +54,7 @@ fn transfer_log_events(
mut log_events: EventWriter<LogEvent>,
) {
// Make sure to use `try_iter()` and not `iter()` to prevent blocking.
log_events.send_batch(receiver.try_iter());
log_events.write_batch(receiver.try_iter());
}
/// This is the [`Layer`] that we will use to capture log events and then send them to Bevy's

2
examples/async_tasks/external_source_external_thread.rs
View File

@ -46,7 +46,7 @@ fn setup(mut commands: Commands) {
// This system reads from the receiver and sends events to Bevy
fn read_stream(receiver: Res<StreamReceiver>, mut events: EventWriter<StreamEvent>) {
for from_stream in receiver.try_iter() {
events.send(StreamEvent(from_stream));
events.write(StreamEvent(from_stream));
}
}

2
examples/audio/pitch.rs
View File

@ -50,6 +50,6 @@ fn keyboard_input_system(
frequency.0 /= ops::powf(2.0f32, 1.0 / 12.0);
}
if keyboard_input.just_pressed(KeyCode::Space) {
events.send(PlayPitch);
events.write(PlayPitch);
}
}

4
examples/ecs/ecs_guide.rs
View File

@ -168,10 +168,10 @@ fn game_over_system(
) {
if let Some(ref player) = game_state.winning_player {
println!("{player} won the game!");
app_exit_events.send(AppExit::Success);
app_exit_events.write(AppExit::Success);
} else if game_state.current_round == game_rules.max_rounds {
println!("Ran out of rounds. Nobody wins!");
app_exit_events.send(AppExit::Success);
app_exit_events.write(AppExit::Success);
}
}

14
examples/ecs/event.rs
View File

@ -34,8 +34,8 @@ impl Default for DamageTimer {
// This system reads 'DamageTimer', updates it, then sends a 'DealDamage' event
// if the timer has finished.
//
// Events are sent using an 'EventWriter<T>' by calling 'send' or 'send_default'.
// The 'send_default' method will send the event with the default value if the event
// Events are sent using an 'EventWriter<T>' by calling 'write' or 'write_default'.
// The 'write_default' method will send the event with the default value if the event
// has a 'Default' implementation.
fn deal_damage_over_time(
time: Res<Time>,
@ -43,8 +43,8 @@ fn deal_damage_over_time(
mut events: EventWriter<DealDamage>,
) {
if state.tick(time.delta()).finished() {
// Events can be sent with 'send' and constructed just like any other object.
events.send(DealDamage { amount: 10 });
// Events can be sent with 'write' and constructed just like any other object.
events.write(DealDamage { amount: 10 });
}
}
@ -62,7 +62,7 @@ fn apply_armor_to_damage(
event.amount -= 1;
if event.amount <= 0 {
// Zero-sized events can also be sent with 'send'
armor_events.send(ArmorBlockedDamage);
armor_events.write(ArmorBlockedDamage);
}
}
}
@ -80,8 +80,8 @@ fn apply_damage_to_health(
for event in dmg_events.read() {
info!("Applying {} damage", event.amount);
if event.amount > 0 {
// Events with a 'Default' implementation can be sent with 'send_default'
rcvd_events.send_default();
// Events with a 'Default' implementation can be written with 'write_default'
rcvd_events.write_default();
}
}
}

2
examples/ecs/observer_propagation.rs
View File

@ -118,7 +118,7 @@ fn take_damage(
} else {
warn!("💀 {} has died a gruesome death", name);
commands.entity(trigger.target()).despawn();
app_exit.send(AppExit::Success);
app_exit.write(AppExit::Success);
}
info!("(propagation reached root)\n");

12
examples/ecs/send_and_receive_events.rs
View File

@ -58,7 +58,7 @@ struct B;
// not at compile time, as Bevy uses internal unsafe code to split the `World` into disjoint pieces.
fn read_and_write_different_event_types(mut a: EventWriter<A>, mut b: EventReader<B>) {
for _ in b.read() {}
a.send(A);
a.write(A);
}
/// A dummy event type.
@ -73,22 +73,22 @@ struct DebugEvent {
fn send_events(mut events: EventWriter<DebugEvent>, frame_count: Res<FrameCount>) {
println!("Sending events for frame {}", frame_count.0);
events.send(DebugEvent {
events.write(DebugEvent {
resend_from_param_set: false,
resend_from_local_event_reader: false,
times_sent: 1,
});
events.send(DebugEvent {
events.write(DebugEvent {
resend_from_param_set: true,
resend_from_local_event_reader: false,
times_sent: 1,
});
events.send(DebugEvent {
events.write(DebugEvent {
resend_from_param_set: false,
resend_from_local_event_reader: true,
times_sent: 1,
});
events.send(DebugEvent {
events.write(DebugEvent {
resend_from_param_set: true,
resend_from_local_event_reader: true,
times_sent: 1,
@ -127,7 +127,7 @@ fn send_and_receive_param_set(
// This is p1, as the second parameter in the `ParamSet` is the writer.
for mut event in events_to_resend {
event.times_sent += 1;
param_set.p1().send(event);
param_set.p1().write(event);
}
}

4
examples/games/breakout.rs
View File

@ -356,8 +356,8 @@ fn check_for_collisions(
);
if let Some(collision) = collision {
// Sends a collision event so that other systems can react to the collision
collision_events.send_default();
// Writes a collision event so that other systems can react to the collision
collision_events.write_default();
// Bricks should be despawned and increment the scoreboard on collision
if maybe_brick.is_some() {

2
examples/games/desk_toy.rs
View File

@ -315,7 +315,7 @@ fn quit(
.distance(cursor_world_pos)
< BEVY_LOGO_RADIUS
{
app_exit.send(AppExit::Success);
app_exit.write(AppExit::Success);
}
}

2
examples/games/game_menu.rs
View File

@ -706,7 +706,7 @@ mod menu {
if *interaction == Interaction::Pressed {
match menu_button_action {
MenuButtonAction::Quit => {
app_exit_events.send(AppExit::Success);
app_exit_events.write(AppExit::Success);
}
MenuButtonAction::Play => {
game_state.set(GameState::Game);

2
examples/helpers/widgets.rs
View File

@ -171,7 +171,7 @@ pub fn handle_ui_interactions<T>(
{
for (interaction, click_event) in interactions.iter_mut() {
if *interaction == Interaction::Pressed {
widget_click_events.send(WidgetClickEvent((**click_event).clone()));
widget_click_events.write(WidgetClickEvent((**click_event).clone()));
}
}
}

10
examples/input/gamepad_rumble.rs
View File

@ -23,7 +23,7 @@ fn gamepad_system(
info!(
"North face button: strong (low-frequency) with low intensity for rumble for 5 seconds. Press multiple times to increase intensity."
);
rumble_requests.send(GamepadRumbleRequest::Add {
rumble_requests.write(GamepadRumbleRequest::Add {
gamepad: entity,
intensity: GamepadRumbleIntensity::strong_motor(0.1),
duration: Duration::from_secs(5),
@ -32,7 +32,7 @@ fn gamepad_system(
if gamepad.just_pressed(GamepadButton::East) {
info!("East face button: maximum rumble on both motors for 5 seconds");
rumble_requests.send(GamepadRumbleRequest::Add {
rumble_requests.write(GamepadRumbleRequest::Add {
gamepad: entity,
duration: Duration::from_secs(5),
intensity: GamepadRumbleIntensity::MAX,
@ -41,7 +41,7 @@ fn gamepad_system(
if gamepad.just_pressed(GamepadButton::South) {
info!("South face button: low-intensity rumble on the weak motor for 0.5 seconds");
rumble_requests.send(GamepadRumbleRequest::Add {
rumble_requests.write(GamepadRumbleRequest::Add {
gamepad: entity,
duration: Duration::from_secs_f32(0.5),
intensity: GamepadRumbleIntensity::weak_motor(0.25),
@ -50,7 +50,7 @@ fn gamepad_system(
if gamepad.just_pressed(GamepadButton::West) {
info!("West face button: custom rumble intensity for 5 second");
rumble_requests.send(GamepadRumbleRequest::Add {
rumble_requests.write(GamepadRumbleRequest::Add {
gamepad: entity,
intensity: GamepadRumbleIntensity {
// intensity low-frequency motor, usually on the left-hand side
@ -64,7 +64,7 @@ fn gamepad_system(
if gamepad.just_pressed(GamepadButton::Start) {
info!("Start button: Interrupt the current rumble");
rumble_requests.send(GamepadRumbleRequest::Stop { gamepad: entity });
rumble_requests.write(GamepadRumbleRequest::Stop { gamepad: entity });
}
}
}

2
examples/ui/size_constraints.rs
View File

@ -269,7 +269,7 @@ fn update_buttons(
for (button_id, interaction, constraint, value) in button_query.iter_mut() {
match interaction {
Interaction::Pressed => {
button_activated_event.send(ButtonActivatedEvent(button_id));
button_activated_event.write(ButtonActivatedEvent(button_id));
match constraint {
Constraint::FlexBasis => {
bar_node.flex_basis = value.0;

4
examples/window/low_power.rs
View File

@ -87,7 +87,7 @@ fn update_winit(
// when there are no inputs, so you send redraw requests while the animation is playing.
// Note that in this example the RequestRedraw winit event will make the app run in the same
// way as continuous
redraw_request_events.send(RequestRedraw);
redraw_request_events.write(RequestRedraw);
WinitSettings::desktop_app()
}
ApplicationWithWakeUp => {
@ -184,7 +184,7 @@ pub(crate) mod test_setup {
Camera3d::default(),
Transform::from_xyz(-2.0, 2.0, 2.0).looking_at(Vec3::ZERO, Vec3::Y),
));
event.send(RequestRedraw);
event.write(RequestRedraw);
commands
.spawn((
Text::default(),

2
tests/how_to_test_systems.rs
View File

@ -27,7 +27,7 @@ fn despawn_dead_enemies(
for (entity, enemy) in &enemies {
if enemy.hit_points == 0 {
commands.entity(entity).despawn();
dead_enemies.send(EnemyDied(enemy.score_value));
dead_enemies.write(EnemyDied(enemy.score_value));
}
}
}