Observers overhaul: statically-typed multi-event-listening and safer dynamic-event-listening

benches/benches/bevy_ecs/observers/dynamic.rs

@@ -0,0 +1,51 @@
+use bevy_ecs::{
+    event::Event,
+    observer::{DynamicEvent, EmitDynamicTrigger, EventSet, Observer, Trigger},
+    world::{Command, World},
+};
+use criterion::{black_box, Criterion};
+
+pub fn observe_dynamic(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("observe_dynamic");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+    group.measurement_time(std::time::Duration::from_secs(4));
+
+    group.bench_function("1", |bencher| {
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<TestEvent<1>>();
+        world.spawn(Observer::new(empty_listener_set::<DynamicEvent>).with_event(event_id_1));
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                unsafe {
+                    EmitDynamicTrigger::new_with_id(event_id_1, TestEvent::<1>, ())
+                        .apply(&mut world)
+                };
+            }
+        });
+    });
+    group.bench_function("2", |bencher| {
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<TestEvent<1>>();
+        let event_id_2 = world.init_component::<TestEvent<2>>();
+        world.spawn(
+            Observer::new(empty_listener_set::<DynamicEvent>)
+                .with_event(event_id_1)
+                .with_event(event_id_2),
+        );
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                unsafe {
+                    EmitDynamicTrigger::new_with_id(event_id_2, TestEvent::<2>, ())
+                        .apply(&mut world)
+                };
+            }
+        });
+    });
+}
+
+#[derive(Event)]
+struct TestEvent<const N: usize>;
+
+fn empty_listener_set<Set: EventSet>(trigger: Trigger<Set>) {
+    black_box(trigger);
+}

benches/benches/bevy_ecs/observers/mod.rs

@@ -1,8 +1,21 @@
 use criterion::criterion_group;
 
+mod dynamic;
+mod multievent;
 mod propagation;
+mod semidynamic;
 mod simple;
+use dynamic::*;
+use multievent::*;
 use propagation::*;
+use semidynamic::*;
 use simple::*;
 
-criterion_group!(observer_benches, event_propagation, observe_simple);
+criterion_group!(
+    observer_benches,
+    event_propagation,
+    observe_simple,
+    observe_multievent,
+    observe_dynamic,
+    observe_semidynamic
+);

benches/benches/bevy_ecs/observers/multievent.rs

@@ -0,0 +1,105 @@
+use bevy_ecs::{
+    component::Component,
+    event::Event,
+    observer::{EventSet, Observer, Trigger},
+    world::World,
+};
+use criterion::{black_box, measurement::WallTime, BenchmarkGroup, Criterion};
+
+pub fn observe_multievent(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("observe_multievent");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+    group.measurement_time(std::time::Duration::from_secs(4));
+
+    group.bench_function("trigger_single", |bencher| {
+        let mut world = World::new();
+        world.observe(empty_listener_set::<TestEvent<1>>);
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                world.trigger(TestEvent::<1>);
+            }
+        });
+    });
+
+    bench_in_set::<1, (TestEvent<1>,)>(&mut group);
+    bench_in_set::<2, (TestEvent<1>, TestEvent<2>)>(&mut group);
+    bench_in_set::<4, (TestEvent<1>, TestEvent<2>, TestEvent<3>, TestEvent<4>)>(&mut group);
+    bench_in_set::<
+        8,
+        (
+            TestEvent<1>,
+            TestEvent<2>,
+            TestEvent<3>,
+            TestEvent<4>,
+            TestEvent<5>,
+            TestEvent<6>,
+            TestEvent<7>,
+            TestEvent<8>,
+        ),
+    >(&mut group);
+    bench_in_set::<
+        12,
+        (
+            TestEvent<1>,
+            TestEvent<2>,
+            TestEvent<3>,
+            TestEvent<4>,
+            TestEvent<5>,
+            TestEvent<6>,
+            TestEvent<7>,
+            TestEvent<8>,
+            TestEvent<9>,
+            TestEvent<10>,
+            TestEvent<11>,
+            TestEvent<12>,
+        ),
+    >(&mut group);
+    bench_in_set::<
+        15,
+        (
+            TestEvent<1>,
+            TestEvent<2>,
+            TestEvent<3>,
+            TestEvent<4>,
+            TestEvent<5>,
+            TestEvent<6>,
+            TestEvent<7>,
+            TestEvent<8>,
+            TestEvent<9>,
+            TestEvent<10>,
+            TestEvent<11>,
+            TestEvent<12>,
+            TestEvent<13>,
+            TestEvent<14>,
+            TestEvent<15>,
+        ),
+    >(&mut group);
+}
+
+fn bench_in_set<const LAST: usize, Set: EventSet>(group: &mut BenchmarkGroup<WallTime>) {
+    group.bench_function(format!("trigger_first/{LAST}"), |bencher| {
+        let mut world = World::new();
+        world.observe(empty_listener_set::<Set>);
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                world.trigger(TestEvent::<1>);
+            }
+        });
+    });
+    group.bench_function(format!("trigger_last/{LAST}"), |bencher| {
+        let mut world = World::new();
+        world.observe(empty_listener_set::<Set>);
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                world.trigger(TestEvent::<LAST>);
+            }
+        });
+    });
+}
+
+#[derive(Event)]
+struct TestEvent<const N: usize>;
+
+fn empty_listener_set<Set: EventSet>(trigger: Trigger<Set>) {
+    black_box(trigger);
+}

benches/benches/bevy_ecs/observers/semidynamic.rs

@@ -0,0 +1,183 @@
+use bevy_ecs::{
+    event::Event,
+    observer::{EmitDynamicTrigger, EventSet, Observer, SemiDynamicEvent, Trigger},
+    world::{Command, World},
+};
+use criterion::{black_box, Criterion};
+
+pub fn observe_semidynamic(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("observe_semidynamic");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+    group.measurement_time(std::time::Duration::from_secs(4));
+
+    group.bench_function("static/1s-1d", |bencher| {
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<Dynamic<1>>();
+        world.spawn(
+            Observer::new(empty_listener_set::<SemiDynamicEvent<Static<1>>>).with_event(event_id_1),
+        );
+
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                world.trigger(Static::<1>);
+            }
+        });
+    });
+    group.bench_function("dynamic/1s-1d", |bencher| {
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<Dynamic<1>>();
+        world.spawn(
+            Observer::new(empty_listener_set::<SemiDynamicEvent<Static<1>>>).with_event(event_id_1),
+        );
+
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                unsafe {
+                    EmitDynamicTrigger::new_with_id(event_id_1, Dynamic::<1>, ()).apply(&mut world)
+                };
+            }
+        });
+    });
+
+    group.bench_function("static/15s-15d", |bencher| {
+        // Aint she perdy?
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<Dynamic<1>>();
+        let event_id_2 = world.init_component::<Dynamic<2>>();
+        let event_id_3 = world.init_component::<Dynamic<3>>();
+        let event_id_4 = world.init_component::<Dynamic<4>>();
+        let event_id_5 = world.init_component::<Dynamic<5>>();
+        let event_id_6 = world.init_component::<Dynamic<6>>();
+        let event_id_7 = world.init_component::<Dynamic<7>>();
+        let event_id_8 = world.init_component::<Dynamic<8>>();
+        let event_id_9 = world.init_component::<Dynamic<9>>();
+        let event_id_10 = world.init_component::<Dynamic<10>>();
+        let event_id_11 = world.init_component::<Dynamic<11>>();
+        let event_id_12 = world.init_component::<Dynamic<12>>();
+        let event_id_13 = world.init_component::<Dynamic<13>>();
+        let event_id_14 = world.init_component::<Dynamic<14>>();
+        let event_id_15 = world.init_component::<Dynamic<15>>();
+        world.spawn(
+            Observer::new(
+                empty_listener_set::<
+                    SemiDynamicEvent<(
+                        Static<1>,
+                        Static<2>,
+                        Static<3>,
+                        Static<4>,
+                        Static<5>,
+                        Static<6>,
+                        Static<7>,
+                        Static<8>,
+                        Static<9>,
+                        Static<10>,
+                        Static<11>,
+                        Static<12>,
+                        Static<13>,
+                        Static<14>,
+                        Static<15>,
+                    )>,
+                >,
+            )
+            .with_event(event_id_1)
+            .with_event(event_id_2)
+            .with_event(event_id_3)
+            .with_event(event_id_4)
+            .with_event(event_id_5)
+            .with_event(event_id_6)
+            .with_event(event_id_7)
+            .with_event(event_id_8)
+            .with_event(event_id_9)
+            .with_event(event_id_10)
+            .with_event(event_id_11)
+            .with_event(event_id_12)
+            .with_event(event_id_13)
+            .with_event(event_id_14)
+            .with_event(event_id_15),
+        );
+
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                world.trigger(Static::<14>);
+            }
+        });
+    });
+    group.bench_function("dynamic/15s-15d", |bencher| {
+        // Aint she perdy?
+        let mut world = World::new();
+        let event_id_1 = world.init_component::<Dynamic<1>>();
+        let event_id_2 = world.init_component::<Dynamic<2>>();
+        let event_id_3 = world.init_component::<Dynamic<3>>();
+        let event_id_4 = world.init_component::<Dynamic<4>>();
+        let event_id_5 = world.init_component::<Dynamic<5>>();
+        let event_id_6 = world.init_component::<Dynamic<6>>();
+        let event_id_7 = world.init_component::<Dynamic<7>>();
+        let event_id_8 = world.init_component::<Dynamic<8>>();
+        let event_id_9 = world.init_component::<Dynamic<9>>();
+        let event_id_10 = world.init_component::<Dynamic<10>>();
+        let event_id_11 = world.init_component::<Dynamic<11>>();
+        let event_id_12 = world.init_component::<Dynamic<12>>();
+        let event_id_13 = world.init_component::<Dynamic<13>>();
+        let event_id_14 = world.init_component::<Dynamic<14>>();
+        let event_id_15 = world.init_component::<Dynamic<15>>();
+        world.spawn(
+            Observer::new(
+                empty_listener_set::<
+                    SemiDynamicEvent<(
+                        Static<1>,
+                        Static<2>,
+                        Static<3>,
+                        Static<4>,
+                        Static<5>,
+                        Static<6>,
+                        Static<7>,
+                        Static<8>,
+                        Static<9>,
+                        Static<10>,
+                        Static<11>,
+                        Static<12>,
+                        Static<13>,
+                        Static<14>,
+                        Static<15>,
+                    )>,
+                >,
+            )
+            .with_event(event_id_1)
+            .with_event(event_id_2)
+            .with_event(event_id_3)
+            .with_event(event_id_4)
+            .with_event(event_id_5)
+            .with_event(event_id_6)
+            .with_event(event_id_7)
+            .with_event(event_id_8)
+            .with_event(event_id_9)
+            .with_event(event_id_10)
+            .with_event(event_id_11)
+            .with_event(event_id_12)
+            .with_event(event_id_13)
+            .with_event(event_id_14)
+            .with_event(event_id_15),
+        );
+
+        bencher.iter(|| {
+            for _ in 0..10000 {
+                unsafe {
+                    EmitDynamicTrigger::new_with_id(event_id_14, Dynamic::<14>, ())
+                        .apply(&mut world)
+                };
+            }
+        });
+    });
+}
+
+/// Static event type
+#[derive(Event)]
+struct Static<const N: usize>;
+
+/// Dynamic event type
+#[derive(Event)]
+struct Dynamic<const N: usize>;
+
+fn empty_listener_set<Set: EventSet>(trigger: Trigger<Set>) {
+    black_box(trigger);
+}

crates/bevy_app/src/app.rs

@@ -6,6 +6,7 @@ pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     event::{event_update_system, EventCursor},
     intern::Interned,
+    observer::EventSet,
     prelude::*,
     schedule::{ScheduleBuildSettings, ScheduleLabel},
     system::{IntoObserverSystem, SystemId},
@@ -990,7 +991,7 @@ impl App {
     }
 
     /// Spawns an [`Observer`] entity, which will watch for and respond to the given event.
-    pub fn observe<E: Event, B: Bundle, M>(
+    pub fn observe<E: EventSet, B: Bundle, M>(
         &mut self,
         observer: impl IntoObserverSystem<E, B, M>,
     ) -> &mut Self {