From 65449ea4e2a7b6ace737a13f75217deb08c675ad Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Thu, 11 Apr 2024 20:52:27 -0700
Subject: [PATCH 01/19] Optimize Event Updates

---
 crates/bevy_app/src/app.rs     |  9 +++--
 crates/bevy_app/src/sub_app.rs | 10 ++----
 crates/bevy_ecs/src/event.rs   | 66 +++++++++++++++++++++++-----------
 3 files changed, 56 insertions(+), 29 deletions(-)

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index a676214d5dc47..642a1882f4fba 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,8 +1,10 @@
 use crate::{
-    Main, MainSchedulePlugin, PlaceholderPlugin, Plugin, Plugins, PluginsState, SubApp, SubApps,
+    First, Main, MainSchedulePlugin, PlaceholderPlugin, Plugin, Plugins, PluginsState, SubApp,
+    SubApps,
 };
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
+    event::event_update_system,
     intern::Interned,
     prelude::*,
     schedule::{ScheduleBuildSettings, ScheduleLabel},
@@ -89,7 +91,10 @@ impl Default for App {
         #[cfg(feature = "bevy_reflect")]
         app.init_resource::<AppTypeRegistry>();
         app.add_plugins(MainSchedulePlugin);
-
+        app.add_systems(
+            First,
+            event_update_system.in_set(bevy_ecs::event::EventUpdates),
+        );
         app.add_event::<AppExit>();
 
         app
diff --git a/crates/bevy_app/src/sub_app.rs b/crates/bevy_app/src/sub_app.rs
index b4baa6968925d..c24291a2cc1ae 100644
--- a/crates/bevy_app/src/sub_app.rs
+++ b/crates/bevy_app/src/sub_app.rs
@@ -1,5 +1,6 @@
-use crate::{App, First, InternedAppLabel, Plugin, Plugins, PluginsState, StateTransition};
+use crate::{App, InternedAppLabel, Plugin, Plugins, PluginsState, StateTransition};
 use bevy_ecs::{
+    event::EventRegistry,
     prelude::*,
     schedule::{
         common_conditions::run_once as run_once_condition, run_enter_schedule,
@@ -362,12 +363,7 @@ impl SubApp {
         T: Event,
     {
         if !self.world.contains_resource::<Events<T>>() {
-            self.init_resource::<Events<T>>().add_systems(
-                First,
-                bevy_ecs::event::event_update_system::<T>
-                    .in_set(bevy_ecs::event::EventUpdates)
-                    .run_if(bevy_ecs::event::event_update_condition::<T>),
-            );
+            EventRegistry::register_event::<T>(self.world_mut());
         }
 
         self
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index af7b6df6b6a27..dcfd141229125 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -1,7 +1,11 @@
 //! Event handling types.
 
 use crate as bevy_ecs;
-use crate::system::{Local, Res, ResMut, Resource, SystemParam};
+use crate::{
+    change_detection::Mut,
+    system::{Local, Res, ResMut, Resource, SystemParam},
+    world::World,
+};
 pub use bevy_ecs_macros::Event;
 use bevy_ecs_macros::SystemSet;
 use bevy_utils::detailed_trace;
@@ -253,7 +257,8 @@ impl<E: Event> Events<E> {
     ///
     /// If you need access to the events that were removed, consider using [`Events::update_drain`].
     pub fn update(&mut self) {
-        let _ = self.update_drain();
+        std::mem::swap(&mut self.events_a, &mut self.events_b);
+        self.events_b.clear();
     }
 
     /// Swaps the event buffers and drains the oldest event buffer, returning an iterator
@@ -798,6 +803,40 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
     }
 }
 
+/// A registry of all of the [`Events`] in the [`World`], used by [`event_update_system`]
+/// to update all of the events.
+#[derive(Resource, Default)]
+pub struct EventRegistry {
+    event_updates: Vec<fn(&mut World)>,
+}
+
+impl EventRegistry {
+    /// Registers an event type to be updated.
+    pub fn register_event<T: Event>(world: &mut World) {
+        world.init_resource::<Events<T>>();
+        let mut registry = world.get_resource_or_insert_with(|| Self::default());
+        registry.event_updates.push(|world| {
+            if let Some(mut events) = world.get_resource_mut::<Events<T>>() {
+                events.update();
+            }
+        });
+    }
+
+    /// Updates all of the registered events in the World.
+    pub fn run_updates(&mut self, world: &mut World) {
+        if let Some(signal) = world.get_resource::<EventUpdateSignal>() {
+            // If we haven't got a signal to update the events, but we *could* get such a signal
+            // return early and update the events later.
+            if !signal.0 {
+                return;
+            }
+        }
+        for update in &mut self.event_updates {
+            update(world)
+        }
+    }
+}
+
 #[doc(hidden)]
 #[derive(Resource, Default)]
 pub struct EventUpdateSignal(bool);
@@ -821,25 +860,12 @@ pub fn reset_event_update_signal_system(signal: Option<ResMut<EventUpdateSignal>
 }
 
 /// A system that calls [`Events::update`].
-pub fn event_update_system<T: Event>(
-    update_signal: Option<Res<EventUpdateSignal>>,
-    mut events: ResMut<Events<T>>,
-) {
-    if let Some(signal) = update_signal {
-        // If we haven't got a signal to update the events, but we *could* get such a signal
-        // return early and update the events later.
-        if !signal.0 {
-            return;
-        }
+pub fn event_update_system(world: &mut World) {
+    if world.contains_resource::<EventRegistry>() {
+        world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
+            registry.run_updates(world);
+        });
     }
-
-    events.update();
-}
-
-/// A run condition that checks if the event's [`event_update_system`]
-/// needs to run or not.
-pub fn event_update_condition<T: Event>(events: Res<Events<T>>) -> bool {
-    !events.events_a.is_empty() || !events.events_b.is_empty()
 }
 
 /// [`Iterator`] over sent [`EventIds`](`EventId`) from a batch.

From dd932841febb345e00db8142f6e651c461c1838a Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 01:04:33 -0700
Subject: [PATCH 02/19] Avoid context switches from time systems

---
 crates/bevy_app/src/app.rs   |  6 +++---
 crates/bevy_ecs/src/event.rs | 23 +++++++++--------------
 crates/bevy_time/src/lib.rs  | 23 ++++++++++-------------
 crates/bevy_time/src/virt.rs |  7 +------
 4 files changed, 23 insertions(+), 36 deletions(-)

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 642a1882f4fba..65c8f0196cd42 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -93,7 +93,9 @@ impl Default for App {
         app.add_plugins(MainSchedulePlugin);
         app.add_systems(
             First,
-            event_update_system.in_set(bevy_ecs::event::EventUpdates),
+            event_update_system
+                .in_set(bevy_ecs::event::EventUpdates)
+                .run_if(bevy_ecs::event::event_update_condition),
         );
         app.add_event::<AppExit>();
 
@@ -374,8 +376,6 @@ impl App {
     /// #
     /// app.add_event::<MyEvent>();
     /// ```
-    ///
-    /// [`event_update_system`]: bevy_ecs::event::event_update_system
     pub fn add_event<T>(&mut self) -> &mut Self
     where
         T: Event,
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index dcfd141229125..b6d529a52dc05 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -824,13 +824,6 @@ impl EventRegistry {
 
     /// Updates all of the registered events in the World.
     pub fn run_updates(&mut self, world: &mut World) {
-        if let Some(signal) = world.get_resource::<EventUpdateSignal>() {
-            // If we haven't got a signal to update the events, but we *could* get such a signal
-            // return early and update the events later.
-            if !signal.0 {
-                return;
-            }
-        }
         for update in &mut self.event_updates {
             update(world)
         }
@@ -852,13 +845,6 @@ pub fn signal_event_update_system(signal: Option<ResMut<EventUpdateSignal>>) {
     }
 }
 
-/// Resets the `EventUpdateSignal`
-pub fn reset_event_update_signal_system(signal: Option<ResMut<EventUpdateSignal>>) {
-    if let Some(mut s) = signal {
-        s.0 = false;
-    }
-}
-
 /// A system that calls [`Events::update`].
 pub fn event_update_system(world: &mut World) {
     if world.contains_resource::<EventRegistry>() {
@@ -866,6 +852,15 @@ pub fn event_update_system(world: &mut World) {
             registry.run_updates(world);
         });
     }
+    if let Some(mut s) = world.get_resource_mut::<EventUpdateSignal>() {
+        s.0 = false;
+    }
+}
+
+pub fn event_update_condition(signal: Option<Res<EventUpdateSignal>>) -> bool {
+    // If we haven't got a signal to update the events, but we *could* get such a signal
+    // return early and update the events later.
+    signal.map(|signal| signal.0).unwrap_or(false)
 }
 
 /// [`Iterator`] over sent [`EventIds`](`EventId`) from a batch.
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 3119f023523e9..2365a9d4f4be7 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -30,7 +30,7 @@ pub mod prelude {
 }
 
 use bevy_app::{prelude::*, RunFixedMainLoop};
-use bevy_ecs::event::{signal_event_update_system, EventUpdateSignal, EventUpdates};
+use bevy_ecs::event::{signal_event_update_system, EventUpdateSignal};
 use bevy_ecs::prelude::*;
 use bevy_utils::{tracing::warn, Duration, Instant};
 pub use crossbeam_channel::TrySendError;
@@ -57,18 +57,11 @@ impl Plugin for TimePlugin {
             .register_type::<Time<Virtual>>()
             .register_type::<Time<Fixed>>()
             .register_type::<Timer>()
-            .add_systems(
-                First,
-                (time_system, virtual_time_system.after(time_system)).in_set(TimeSystem),
-            )
+            .add_systems(First, time_system.in_set(TimeSystem))
             .add_systems(RunFixedMainLoop, run_fixed_main_schedule);
 
         // ensure the events are not dropped until `FixedMain` systems can observe them
         app.init_resource::<EventUpdateSignal>()
-            .add_systems(
-                First,
-                bevy_ecs::event::reset_event_update_signal_system.after(EventUpdates),
-            )
             .add_systems(FixedPostUpdate, signal_event_update_system);
     }
 }
@@ -111,7 +104,9 @@ pub fn create_time_channels() -> (TimeSender, TimeReceiver) {
 /// The system used to update the [`Time`] used by app logic. If there is a render world the time is
 /// sent from there to this system through channels. Otherwise the time is updated in this system.
 fn time_system(
-    mut time: ResMut<Time<Real>>,
+    mut real_time: ResMut<Time<Real>>,
+    mut virtual_time: ResMut<Time<Virtual>>,
+    mut time: ResMut<Time>,
     update_strategy: Res<TimeUpdateStrategy>,
     time_recv: Option<Res<TimeReceiver>>,
     mut has_received_time: Local<bool>,
@@ -132,10 +127,12 @@ fn time_system(
     };
 
     match update_strategy.as_ref() {
-        TimeUpdateStrategy::Automatic => time.update_with_instant(new_time),
-        TimeUpdateStrategy::ManualInstant(instant) => time.update_with_instant(*instant),
-        TimeUpdateStrategy::ManualDuration(duration) => time.update_with_duration(*duration),
+        TimeUpdateStrategy::Automatic => real_time.update_with_instant(new_time),
+        TimeUpdateStrategy::ManualInstant(instant) => real_time.update_with_instant(*instant),
+        TimeUpdateStrategy::ManualDuration(duration) => real_time.update_with_duration(*duration),
     }
+
+    update_virtual_time(&mut time, &mut virtual_time, &real_time);
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_time/src/virt.rs b/crates/bevy_time/src/virt.rs
index e1760df497e22..0f8676c9f8880 100644
--- a/crates/bevy_time/src/virt.rs
+++ b/crates/bevy_time/src/virt.rs
@@ -1,4 +1,3 @@
-use bevy_ecs::system::{Res, ResMut};
 use bevy_reflect::Reflect;
 use bevy_utils::{tracing::debug, Duration};
 
@@ -268,11 +267,7 @@ impl Default for Virtual {
 /// Advances [`Time<Virtual>`] and [`Time`] based on the elapsed [`Time<Real>`].
 ///
 /// The virtual time will be advanced up to the provided [`Time::max_delta`].
-pub fn virtual_time_system(
-    mut current: ResMut<Time>,
-    mut virt: ResMut<Time<Virtual>>,
-    real: Res<Time<Real>>,
-) {
+pub fn update_virtual_time(current: &mut Time, virt: &mut Time<Virtual>, real: &Time<Real>) {
     let raw_delta = real.delta();
     virt.advance_with_raw_delta(raw_delta);
     *current = virt.as_generic();

From 59a3d3c99d3536a23e1e88839407c54dae46f923 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 01:14:58 -0700
Subject: [PATCH 03/19] Clippy

---
 crates/bevy_ecs/src/event.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index b6d529a52dc05..d6adaa71002a1 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -814,7 +814,7 @@ impl EventRegistry {
     /// Registers an event type to be updated.
     pub fn register_event<T: Event>(world: &mut World) {
         world.init_resource::<Events<T>>();
-        let mut registry = world.get_resource_or_insert_with(|| Self::default());
+        let mut registry = world.get_resource_or_insert_with(Self::default);
         registry.event_updates.push(|world| {
             if let Some(mut events) = world.get_resource_mut::<Events<T>>() {
                 events.update();
@@ -825,7 +825,7 @@ impl EventRegistry {
     /// Updates all of the registered events in the World.
     pub fn run_updates(&mut self, world: &mut World) {
         for update in &mut self.event_updates {
-            update(world)
+            update(world);
         }
     }
 }
@@ -845,7 +845,7 @@ pub fn signal_event_update_system(signal: Option<ResMut<EventUpdateSignal>>) {
     }
 }
 
-/// A system that calls [`Events::update`].
+/// A system that calls [`Events::update`] on all registered [`Events`] in the world.
 pub fn event_update_system(world: &mut World) {
     if world.contains_resource::<EventRegistry>() {
         world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
@@ -857,6 +857,7 @@ pub fn event_update_system(world: &mut World) {
     }
 }
 
+/// A run condition for [`event_update_system`].
 pub fn event_update_condition(signal: Option<Res<EventUpdateSignal>>) -> bool {
     // If we haven't got a signal to update the events, but we *could* get such a signal
     // return early and update the events later.

From 4a6e1966a37f8d08f5f28029f013cdfeaeb721da Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 01:36:17 -0700
Subject: [PATCH 04/19] Fix examples and doctests

---
 crates/bevy_ecs/examples/events.rs        | 6 +++---
 crates/bevy_ecs/src/schedule/condition.rs | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/examples/events.rs b/crates/bevy_ecs/examples/events.rs
index f75ca81b50b5f..4b93293cef8e9 100644
--- a/crates/bevy_ecs/examples/events.rs
+++ b/crates/bevy_ecs/examples/events.rs
@@ -1,12 +1,12 @@
 //! In this example a system sends a custom event with a 50/50 chance during any frame.
 //! If an event was send, it will be printed by the console in a receiving system.
 
-use bevy_ecs::prelude::*;
+use bevy_ecs::{prelude::*, event::EventRegistry};
 
 fn main() {
     // Create a new empty world and add the event as a resource
     let mut world = World::new();
-    world.insert_resource(Events::<MyEvent>::default());
+    EventRegistry::register_event::<MyEvent>(&mut world);
 
     // Create a schedule to store our systems
     let mut schedule = Schedule::default();
@@ -17,7 +17,7 @@ fn main() {
     #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
     pub struct FlushEvents;
 
-    schedule.add_systems(bevy_ecs::event::event_update_system::<MyEvent>.in_set(FlushEvents));
+    schedule.add_systems(bevy_ecs::event::event_update_system.in_set(FlushEvents));
 
     // Add systems sending and receiving events after the events are flushed.
     schedule.add_systems((
diff --git a/crates/bevy_ecs/src/schedule/condition.rs b/crates/bevy_ecs/src/schedule/condition.rs
index 95e2442e271b6..4c438acc56490 100644
--- a/crates/bevy_ecs/src/schedule/condition.rs
+++ b/crates/bevy_ecs/src/schedule/condition.rs
@@ -837,7 +837,7 @@ pub mod common_conditions {
     /// # let mut world = World::new();
     /// # world.init_resource::<Counter>();
     /// # world.init_resource::<Events<MyEvent>>();
-    /// # app.add_systems(bevy_ecs::event::event_update_system::<MyEvent>.before(my_system));
+    /// # app.add_systems(bevy_ecs::event::event_update_system.before(my_system));
     ///
     /// app.add_systems(
     ///     my_system.run_if(on_event::<MyEvent>()),

From 5a9f98a038cdd7fe94ba6d34dc03979bdbccfc1b Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 01:37:59 -0700
Subject: [PATCH 05/19] Formatting

---
 crates/bevy_ecs/examples/events.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/examples/events.rs b/crates/bevy_ecs/examples/events.rs
index 4b93293cef8e9..6820716ba7c3d 100644
--- a/crates/bevy_ecs/examples/events.rs
+++ b/crates/bevy_ecs/examples/events.rs
@@ -1,7 +1,7 @@
 //! In this example a system sends a custom event with a 50/50 chance during any frame.
 //! If an event was send, it will be printed by the console in a receiving system.
 
-use bevy_ecs::{prelude::*, event::EventRegistry};
+use bevy_ecs::{event::EventRegistry, prelude::*};
 
 fn main() {
     // Create a new empty world and add the event as a resource

From b9830cb49c084d3bb5d00e30c8e1ee7948101295 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 01:47:33 -0700
Subject: [PATCH 06/19] Fix debug assert

---
 crates/bevy_ecs/src/event.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index d6adaa71002a1..7203cdcd3f30f 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -259,6 +259,11 @@ impl<E: Event> Events<E> {
     pub fn update(&mut self) {
         std::mem::swap(&mut self.events_a, &mut self.events_b);
         self.events_b.clear();
+        self.events_b.start_event_count = self.event_count;
+        debug_assert_eq!(
+            self.events_a.start_event_count + self.events_a.len(),
+            self.events_b.start_event_count
+        );
     }
 
     /// Swaps the event buffers and drains the oldest event buffer, returning an iterator

From f790cd2936a3bb9555530cbf21fed8f5a25842da Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 10:45:52 -0700
Subject: [PATCH 07/19] Update crates/bevy_ecs/src/event.rs

Co-authored-by: Josh Matthews <josh@joshmatthews.net>
---
 crates/bevy_ecs/src/event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 7203cdcd3f30f..c2a095165ab2e 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -866,7 +866,7 @@ pub fn event_update_system(world: &mut World) {
 pub fn event_update_condition(signal: Option<Res<EventUpdateSignal>>) -> bool {
     // If we haven't got a signal to update the events, but we *could* get such a signal
     // return early and update the events later.
-    signal.map(|signal| signal.0).unwrap_or(false)
+    signal.map_or(false, |signal| signal.0)
 }
 
 /// [`Iterator`] over sent [`EventIds`](`EventId`) from a batch.

From c53777b10c8efec0c992d9e02423beb42ff59b47 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 11:09:01 -0700
Subject: [PATCH 08/19] Cache component IDs

---
 crates/bevy_ecs/src/event.rs | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index c2a095165ab2e..93a83ffc0aa15 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -2,7 +2,9 @@
 
 use crate as bevy_ecs;
 use crate::{
+    change_detection::DetectChangesMut,
     change_detection::Mut,
+    component::ComponentId,
     system::{Local, Res, ResMut, Resource, SystemParam},
     world::World,
 };
@@ -812,25 +814,29 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
 /// to update all of the events.
 #[derive(Resource, Default)]
 pub struct EventRegistry {
-    event_updates: Vec<fn(&mut World)>,
+    event_updates: Vec<(ComponentId, fn(ComponentId, &mut World))>,
 }
 
 impl EventRegistry {
     /// Registers an event type to be updated.
     pub fn register_event<T: Event>(world: &mut World) {
-        world.init_resource::<Events<T>>();
+        let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_insert_with(Self::default);
-        registry.event_updates.push(|world| {
-            if let Some(mut events) = world.get_resource_mut::<Events<T>>() {
-                events.update();
+        registry.event_updates.push((component_id, |id, world| {
+            // Bypass the type ID -> Component ID lookup with the cached component ID.
+            if let Some(ptr) = world.get_resource_mut_by_id(id) {
+                // SAFETY: The component was initialized with the type Events<T>.
+                unsafe { ptr.with_type::<Events<T>>() }
+                    .bypass_change_detection()
+                    .update()
             }
-        });
+        }));
     }
 
     /// Updates all of the registered events in the World.
     pub fn run_updates(&mut self, world: &mut World) {
-        for update in &mut self.event_updates {
-            update(world);
+        for (component_id, update) in &mut self.event_updates {
+            update(*component_id, world);
         }
     }
 }

From 9759e9c4dfcf8821180a83e5899115e0456c5060 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 12:29:40 -0700
Subject: [PATCH 09/19] Semicolon

---
 crates/bevy_ecs/src/event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 93a83ffc0aa15..9e09191b4baba 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -828,7 +828,7 @@ impl EventRegistry {
                 // SAFETY: The component was initialized with the type Events<T>.
                 unsafe { ptr.with_type::<Events<T>>() }
                     .bypass_change_detection()
-                    .update()
+                    .update();
             }
         }));
     }

From c906686156b5c37622ff99e8611f7089289cf176 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 14:57:07 -0700
Subject: [PATCH 10/19] Use change detection to avoid dynamic dispatch where
 possible

---
 crates/bevy_ecs/src/change_detection.rs |  4 +++
 crates/bevy_ecs/src/event.rs            | 41 ++++++++++++++-----------
 2 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_ecs/src/change_detection.rs b/crates/bevy_ecs/src/change_detection.rs
index bca6aa2a3851a..b0024d1f1669e 100644
--- a/crates/bevy_ecs/src/change_detection.rs
+++ b/crates/bevy_ecs/src/change_detection.rs
@@ -833,6 +833,10 @@ impl<'w> MutUntyped<'w> {
         }
     }
 
+    pub fn has_changed_since(&self, tick: Tick) -> bool {
+        self.ticks.changed.is_newer_than(tick, self.ticks.this_run)
+    }
+
     /// Returns a pointer to the value without taking ownership of this smart pointer, marking it as changed.
     ///
     /// In order to avoid marking the value as changed, you need to call [`bypass_change_detection`](DetectChangesMut::bypass_change_detection).
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 9e09191b4baba..de2247fc7a5f2 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -1,10 +1,10 @@
 //! Event handling types.
 
 use crate as bevy_ecs;
+use crate::change_detection::MutUntyped;
 use crate::{
-    change_detection::DetectChangesMut,
-    change_detection::Mut,
-    component::ComponentId,
+    change_detection::{DetectChangesMut, Mut},
+    component::{ComponentId, Tick},
     system::{Local, Res, ResMut, Resource, SystemParam},
     world::World,
 };
@@ -814,7 +814,7 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
 /// to update all of the events.
 #[derive(Resource, Default)]
 pub struct EventRegistry {
-    event_updates: Vec<(ComponentId, fn(ComponentId, &mut World))>,
+    event_updates: Vec<(ComponentId, fn(MutUntyped))>,
 }
 
 impl EventRegistry {
@@ -822,21 +822,23 @@ impl EventRegistry {
     pub fn register_event<T: Event>(world: &mut World) {
         let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_insert_with(Self::default);
-        registry.event_updates.push((component_id, |id, world| {
-            // Bypass the type ID -> Component ID lookup with the cached component ID.
-            if let Some(ptr) = world.get_resource_mut_by_id(id) {
-                // SAFETY: The component was initialized with the type Events<T>.
-                unsafe { ptr.with_type::<Events<T>>() }
-                    .bypass_change_detection()
-                    .update();
-            }
+        registry.event_updates.push((component_id, |ptr| {
+            // SAFETY: The component was initialized with the type Events<T>.
+            unsafe { ptr.with_type::<Events<T>>() }
+                .bypass_change_detection()
+                .update();
         }));
     }
 
     /// Updates all of the registered events in the World.
-    pub fn run_updates(&mut self, world: &mut World) {
-        for (component_id, update) in &mut self.event_updates {
-            update(*component_id, world);
+    pub fn run_updates(&self, world: &mut World, last_change_tick: Tick) {
+        for (component_id, update) in &self.event_updates {
+            // Bypass the type ID -> Component ID lookup with the cached component ID.
+            if let Some(events) = world.get_resource_mut_by_id(*component_id) {
+                if events.has_changed_since(last_change_tick) {
+                    update(events);
+                }
+            }
         }
     }
 }
@@ -857,15 +859,18 @@ pub fn signal_event_update_system(signal: Option<ResMut<EventUpdateSignal>>) {
 }
 
 /// A system that calls [`Events::update`] on all registered [`Events`] in the world.
-pub fn event_update_system(world: &mut World) {
+pub fn event_update_system(world: &mut World, mut last_change_tick: Local<Option<Tick>>) {
     if world.contains_resource::<EventRegistry>() {
-        world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
-            registry.run_updates(world);
+        let change_tick = *last_change_tick;
+        let change_tick = change_tick.unwrap_or(Tick::new(0));
+        world.resource_scope(|world, registry: Mut<EventRegistry>| {
+            registry.run_updates(world, change_tick);
         });
     }
     if let Some(mut s) = world.get_resource_mut::<EventUpdateSignal>() {
         s.0 = false;
     }
+    *last_change_tick = Some(world.change_tick());
 }
 
 /// A run condition for [`event_update_system`].

From a5a827158141b382a7f4f337f2f8dc84a97b8d64 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 15:00:09 -0700
Subject: [PATCH 11/19] Apply suggestions from code review

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_ecs/examples/events.rs | 2 ++
 crates/bevy_ecs/src/event.rs       | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/crates/bevy_ecs/examples/events.rs b/crates/bevy_ecs/examples/events.rs
index 6820716ba7c3d..a7894ad938e23 100644
--- a/crates/bevy_ecs/examples/events.rs
+++ b/crates/bevy_ecs/examples/events.rs
@@ -6,6 +6,8 @@ use bevy_ecs::{event::EventRegistry, prelude::*};
 fn main() {
     // Create a new empty world and add the event as a resource
     let mut world = World::new();
+    // The event registry is stored as a resource, and allows us to quickly update all events at once.
+    // This call adds both the registry resource and the events resource into the world.
     EventRegistry::register_event::<MyEvent>(&mut world);
 
     // Create a schedule to store our systems
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index de2247fc7a5f2..4f49117713957 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -820,6 +820,8 @@ pub struct EventRegistry {
 impl EventRegistry {
     /// Registers an event type to be updated.
     pub fn register_event<T: Event>(world: &mut World) {
+        // By initializing the resource here, we can be sure that it is present,
+        // and receive the correct, up-to-date `ComponentId` even if it was previously removed.
         let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_insert_with(Self::default);
         registry.event_updates.push((component_id, |ptr| {

From 908003f2529c59b9be7f6ff401ba0a4397f48041 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 15:05:26 -0700
Subject: [PATCH 12/19] Address review comments

---
 crates/bevy_ecs/src/change_detection.rs |  2 ++
 crates/bevy_ecs/src/event.rs            | 10 +++++++---
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/change_detection.rs b/crates/bevy_ecs/src/change_detection.rs
index b0024d1f1669e..f0b863fc863da 100644
--- a/crates/bevy_ecs/src/change_detection.rs
+++ b/crates/bevy_ecs/src/change_detection.rs
@@ -833,6 +833,8 @@ impl<'w> MutUntyped<'w> {
         }
     }
 
+    /// Returns `true` if this value was changed or mutably dereferenced
+    /// either since a specific change tick.
     pub fn has_changed_since(&self, tick: Tick) -> bool {
         self.ticks.changed.is_newer_than(tick, self.ticks.this_run)
     }
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 4f49117713957..ce511520fc00b 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -814,7 +814,9 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
 /// to update all of the events.
 #[derive(Resource, Default)]
 pub struct EventRegistry {
-    event_updates: Vec<(ComponentId, fn(MutUntyped))>,
+    // SAFETY: The ID and the function must be used in conjunction, or improper type casts
+    // occur.
+    event_updates: Vec<(ComponentId, unsafe fn(MutUntyped))>,
 }
 
 impl EventRegistry {
@@ -825,7 +827,7 @@ impl EventRegistry {
         let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_insert_with(Self::default);
         registry.event_updates.push((component_id, |ptr| {
-            // SAFETY: The component was initialized with the type Events<T>.
+            // SAFETY: The resource was initialized with the type Events<T>.
             unsafe { ptr.with_type::<Events<T>>() }
                 .bypass_change_detection()
                 .update();
@@ -838,7 +840,9 @@ impl EventRegistry {
             // Bypass the type ID -> Component ID lookup with the cached component ID.
             if let Some(events) = world.get_resource_mut_by_id(*component_id) {
                 if events.has_changed_since(last_change_tick) {
-                    update(events);
+                    // SAFETY: The update function pointer is called with the resource
+                    // fetched from the same component ID.
+                    unsafe { update(events) };
                 }
             }
         }

From d726f5ef17a22e8a49dda5dae5c41869559cd0a0 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 15:12:33 -0700
Subject: [PATCH 13/19] Consolidate resources

---
 crates/bevy_ecs/src/event.rs | 22 +++++++++-------------
 crates/bevy_time/src/lib.rs  |  5 ++---
 2 files changed, 11 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index ce511520fc00b..bea29a2ad99ef 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -814,6 +814,7 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
 /// to update all of the events.
 #[derive(Resource, Default)]
 pub struct EventRegistry {
+    needs_update: bool,
     // SAFETY: The ID and the function must be used in conjunction, or improper type casts
     // occur.
     event_updates: Vec<(ComponentId, unsafe fn(MutUntyped))>,
@@ -849,18 +850,14 @@ impl EventRegistry {
     }
 }
 
-#[doc(hidden)]
-#[derive(Resource, Default)]
-pub struct EventUpdateSignal(bool);
-
 #[doc(hidden)]
 #[derive(SystemSet, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct EventUpdates;
 
 /// Signals the [`event_update_system`] to run after `FixedUpdate` systems.
-pub fn signal_event_update_system(signal: Option<ResMut<EventUpdateSignal>>) {
-    if let Some(mut s) = signal {
-        s.0 = true;
+pub fn signal_event_update_system(signal: Option<ResMut<EventRegistry>>) {
+    if let Some(mut registry) = signal {
+        registry.needs_update = true;
     }
 }
 
@@ -869,21 +866,20 @@ pub fn event_update_system(world: &mut World, mut last_change_tick: Local<Option
     if world.contains_resource::<EventRegistry>() {
         let change_tick = *last_change_tick;
         let change_tick = change_tick.unwrap_or(Tick::new(0));
-        world.resource_scope(|world, registry: Mut<EventRegistry>| {
+        world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
             registry.run_updates(world, change_tick);
+            // Disable the system until signal_event_update_system runs again.
+            registry.needs_update = false;
         });
     }
-    if let Some(mut s) = world.get_resource_mut::<EventUpdateSignal>() {
-        s.0 = false;
-    }
     *last_change_tick = Some(world.change_tick());
 }
 
 /// A run condition for [`event_update_system`].
-pub fn event_update_condition(signal: Option<Res<EventUpdateSignal>>) -> bool {
+pub fn event_update_condition(signal: Option<Res<EventRegistry>>) -> bool {
     // If we haven't got a signal to update the events, but we *could* get such a signal
     // return early and update the events later.
-    signal.map_or(false, |signal| signal.0)
+    signal.map_or(false, |signal| signal.needs_update)
 }
 
 /// [`Iterator`] over sent [`EventIds`](`EventId`) from a batch.
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 2365a9d4f4be7..912a600bb237e 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -30,7 +30,7 @@ pub mod prelude {
 }
 
 use bevy_app::{prelude::*, RunFixedMainLoop};
-use bevy_ecs::event::{signal_event_update_system, EventUpdateSignal};
+use bevy_ecs::event::signal_event_update_system;
 use bevy_ecs::prelude::*;
 use bevy_utils::{tracing::warn, Duration, Instant};
 pub use crossbeam_channel::TrySendError;
@@ -61,8 +61,7 @@ impl Plugin for TimePlugin {
             .add_systems(RunFixedMainLoop, run_fixed_main_schedule);
 
         // ensure the events are not dropped until `FixedMain` systems can observe them
-        app.init_resource::<EventUpdateSignal>()
-            .add_systems(FixedPostUpdate, signal_event_update_system);
+        app.add_systems(FixedPostUpdate, signal_event_update_system);
     }
 }
 

From 60e2cf39cd9d404541e239d1335c62c812a464c6 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 12 Apr 2024 15:14:35 -0700
Subject: [PATCH 14/19] Hide EventRegistry

---
 crates/bevy_ecs/src/event.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index bea29a2ad99ef..8d55debb3e34b 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -812,6 +812,7 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
 
 /// A registry of all of the [`Events`] in the [`World`], used by [`event_update_system`]
 /// to update all of the events.
+#[doc(hidden)]
 #[derive(Resource, Default)]
 pub struct EventRegistry {
     needs_update: bool,

From d4b74a1196028e563ffa97757fbd2dd1eadb3080 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Sat, 13 Apr 2024 01:24:27 -0700
Subject: [PATCH 15/19] Fix drop tests

---
 crates/bevy_ecs/src/event.rs | 45 +++++++++++++++++++++++++-----------
 1 file changed, 32 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 8d55debb3e34b..49de921afdc77 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -810,15 +810,22 @@ impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
     }
 }
 
+struct RegisteredEvent {
+    component_id: ComponentId,
+    // Required to flush the secondary buffer and drop events even if left unchanged.
+    previously_updated: bool,
+    // SAFETY: The ID and the function must be used in conjunction, or improper type casts
+    // occur.
+    update: unsafe fn(MutUntyped),
+}
+
 /// A registry of all of the [`Events`] in the [`World`], used by [`event_update_system`]
 /// to update all of the events.
 #[doc(hidden)]
 #[derive(Resource, Default)]
 pub struct EventRegistry {
     needs_update: bool,
-    // SAFETY: The ID and the function must be used in conjunction, or improper type casts
-    // occur.
-    event_updates: Vec<(ComponentId, unsafe fn(MutUntyped))>,
+    event_updates: Vec<RegisteredEvent>,
 }
 
 impl EventRegistry {
@@ -828,23 +835,35 @@ impl EventRegistry {
         // and receive the correct, up-to-date `ComponentId` even if it was previously removed.
         let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_insert_with(Self::default);
-        registry.event_updates.push((component_id, |ptr| {
-            // SAFETY: The resource was initialized with the type Events<T>.
-            unsafe { ptr.with_type::<Events<T>>() }
-                .bypass_change_detection()
-                .update();
-        }));
+        registry.event_updates.push(RegisteredEvent {
+            component_id,
+            previously_updated: false,
+            update: |ptr| {
+                // SAFETY: The resource was initialized with the type Events<T>.
+                unsafe { ptr.with_type::<Events<T>>() }
+                    .bypass_change_detection()
+                    .update();
+            },
+        });
     }
 
     /// Updates all of the registered events in the World.
-    pub fn run_updates(&self, world: &mut World, last_change_tick: Tick) {
-        for (component_id, update) in &self.event_updates {
+    pub fn run_updates(&mut self, world: &mut World, last_change_tick: Tick) {
+        for registered_event in &mut self.event_updates {
             // Bypass the type ID -> Component ID lookup with the cached component ID.
-            if let Some(events) = world.get_resource_mut_by_id(*component_id) {
+            if let Some(events) = world.get_resource_mut_by_id(registered_event.component_id) {
                 if events.has_changed_since(last_change_tick) {
                     // SAFETY: The update function pointer is called with the resource
                     // fetched from the same component ID.
-                    unsafe { update(events) };
+                    unsafe { (registered_event.update)(events) };
+                    registered_event.previously_updated = true;
+                    continue;
+                }
+                if registered_event.previously_updated {
+                    // SAFETY: The update function pointer is called with the resource
+                    // fetched from the same component ID.
+                    unsafe { (registered_event.update)(events) };
+                    registered_event.previously_updated = false;
                 }
             }
         }

From 6f160a8d142442c46b7adbfb80a68e375674f7be Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Sat, 13 Apr 2024 01:29:22 -0700
Subject: [PATCH 16/19] Address review comments

---
 crates/bevy_ecs/src/component.rs |  2 +-
 crates/bevy_ecs/src/event.rs     | 13 +++++--------
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index 808fb148b5f73..2c043fe46c324 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -765,7 +765,7 @@ impl Components {
 
 /// A value that tracks when a system ran relative to other systems.
 /// This is used to power change detection.
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Debug, PartialEq))]
 pub struct Tick {
     tick: u32,
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 49de921afdc77..c03962cf85066 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -814,14 +814,13 @@ struct RegisteredEvent {
     component_id: ComponentId,
     // Required to flush the secondary buffer and drop events even if left unchanged.
     previously_updated: bool,
-    // SAFETY: The ID and the function must be used in conjunction, or improper type casts
-    // occur.
+    // SAFETY: The component ID and the function must be used to fetch the Events<T> resource 
+    // of the same type initalized in `register_event`, or improper type casts will occur.
     update: unsafe fn(MutUntyped),
 }
 
 /// A registry of all of the [`Events`] in the [`World`], used by [`event_update_system`]
 /// to update all of the events.
-#[doc(hidden)]
 #[derive(Resource, Default)]
 pub struct EventRegistry {
     needs_update: bool,
@@ -882,17 +881,15 @@ pub fn signal_event_update_system(signal: Option<ResMut<EventRegistry>>) {
 }
 
 /// A system that calls [`Events::update`] on all registered [`Events`] in the world.
-pub fn event_update_system(world: &mut World, mut last_change_tick: Local<Option<Tick>>) {
+pub fn event_update_system(world: &mut World, mut last_change_tick: Local<Tick>) {
     if world.contains_resource::<EventRegistry>() {
-        let change_tick = *last_change_tick;
-        let change_tick = change_tick.unwrap_or(Tick::new(0));
         world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
-            registry.run_updates(world, change_tick);
+            registry.run_updates(world, *last_change_tick);
             // Disable the system until signal_event_update_system runs again.
             registry.needs_update = false;
         });
     }
-    *last_change_tick = Some(world.change_tick());
+    *last_change_tick = world.change_tick();
 }
 
 /// A run condition for [`event_update_system`].

From c53bca51b3fa43a7a62a5bf33d682d7968d8ed45 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Sat, 13 Apr 2024 01:30:41 -0700
Subject: [PATCH 17/19] Typo

---
 crates/bevy_ecs/src/event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index c03962cf85066..90ba13a518143 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -815,7 +815,7 @@ struct RegisteredEvent {
     // Required to flush the secondary buffer and drop events even if left unchanged.
     previously_updated: bool,
     // SAFETY: The component ID and the function must be used to fetch the Events<T> resource 
-    // of the same type initalized in `register_event`, or improper type casts will occur.
+    // of the same type initialized in `register_event`, or improper type casts will occur.
     update: unsafe fn(MutUntyped),
 }
 

From 836ade6b585925ebe598b755be17d3a8cd4d7aef Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Sat, 13 Apr 2024 01:34:40 -0700
Subject: [PATCH 18/19] Cleanup run_updates

---
 crates/bevy_ecs/src/event.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 90ba13a518143..0feb95fec1b99 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -851,18 +851,14 @@ impl EventRegistry {
         for registered_event in &mut self.event_updates {
             // Bypass the type ID -> Component ID lookup with the cached component ID.
             if let Some(events) = world.get_resource_mut_by_id(registered_event.component_id) {
-                if events.has_changed_since(last_change_tick) {
+                let has_changed = events.has_changed_since(last_change_tick);
+                if registered_event.previously_updated || has_changed {
                     // SAFETY: The update function pointer is called with the resource
                     // fetched from the same component ID.
                     unsafe { (registered_event.update)(events) };
-                    registered_event.previously_updated = true;
-                    continue;
-                }
-                if registered_event.previously_updated {
-                    // SAFETY: The update function pointer is called with the resource
-                    // fetched from the same component ID.
-                    unsafe { (registered_event.update)(events) };
-                    registered_event.previously_updated = false;
+                    // Always set to true if the events have changed, otherwise disable running on the second invocation
+                    // to wait for more changes.
+                    registered_event.previously_updated = has_changed || !registered_event.previously_updated;
                 }
             }
         }

From 99dca64567e4691f6a7b7636315f4e4829a63a9c Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Sat, 13 Apr 2024 01:37:01 -0700
Subject: [PATCH 19/19] Formatting

---
 crates/bevy_ecs/src/event.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 0feb95fec1b99..0b780c6c981d9 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -814,7 +814,7 @@ struct RegisteredEvent {
     component_id: ComponentId,
     // Required to flush the secondary buffer and drop events even if left unchanged.
     previously_updated: bool,
-    // SAFETY: The component ID and the function must be used to fetch the Events<T> resource 
+    // SAFETY: The component ID and the function must be used to fetch the Events<T> resource
     // of the same type initialized in `register_event`, or improper type casts will occur.
     update: unsafe fn(MutUntyped),
 }
@@ -858,7 +858,8 @@ impl EventRegistry {
                     unsafe { (registered_event.update)(events) };
                     // Always set to true if the events have changed, otherwise disable running on the second invocation
                     // to wait for more changes.
-                    registered_event.previously_updated = has_changed || !registered_event.previously_updated;
+                    registered_event.previously_updated =
+                        has_changed || !registered_event.previously_updated;
                 }
             }
         }