Observed entity query data fetching: Trigger<FooEvent, (), (&mut Foo, &Bar)>

crates/bevy_ecs/src/observer/mod.rs

@@ -13,6 +13,7 @@ use crate::{
     entity::EntityHashMap,
     observer::entity_observer::ObservedBy,
     prelude::*,
+    query::QueryData,
     system::IntoObserverSystem,
     world::{DeferredWorld, *},
 };
@@ -27,24 +28,42 @@ use core::{
 /// Type containing triggered [`Event`] information for a given run of an [`Observer`]. This contains the
 /// [`Event`] data itself. If it was triggered for a specific [`Entity`], it includes that as well. It also
 /// contains event propagation information. See [`Trigger::propagate`] for more information.
-pub struct Trigger<'w, E, B: Bundle = ()> {
-    event: &'w mut E,
-    propagate: &'w mut bool,
+pub struct Trigger<'world, 'input, E, B: Bundle = (), D: QueryData + 'static = ()> {
+    event: &'input mut E,
+    propagate: &'input mut bool,
     trigger: ObserverTrigger,
+    data: Option<D::Item<'world>>,
     _marker: PhantomData<B>,
 }
 
-impl<'w, E, B: Bundle> Trigger<'w, E, B> {
+impl<'i, E, B: Bundle> Trigger<'static, 'i, E, B, ()> {
     /// Creates a new trigger for the given event and observer information.
-    pub fn new(event: &'w mut E, propagate: &'w mut bool, trigger: ObserverTrigger) -> Self {
+    pub fn new(event: &'i mut E, propagate: &'i mut bool, trigger: ObserverTrigger) -> Self {
         Self {
             event,
             propagate,
             trigger,
+            data: None,
             _marker: PhantomData,
         }
     }
 
+    /// Creates a new trigger with the given event and observer information, and target query data.
+    pub fn with_data<'w, D: QueryData>(
+        self,
+        data: Option<D::Item<'w>>,
+    ) -> Trigger<'w, 'i, E, B, D> {
+        Trigger {
+            event: self.event,
+            propagate: self.propagate,
+            trigger: self.trigger,
+            data,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<'w, E, B: Bundle, D: QueryData> Trigger<'w, '_, E, B, D> {
     /// Returns the event type of this trigger.
     pub fn event_type(&self) -> ComponentId {
         self.trigger.event_type
@@ -65,6 +84,11 @@ impl<'w, E, B: Bundle> Trigger<'w, E, B> {
         Ptr::from(&self.event)
     }
 
+    /// Returns a reference to the query data associated with the trigger.
+    pub fn data(&mut self) -> Option<&mut D::Item<'w>> {
+        self.data.as_mut()
+    }
+
     /// Returns the [`Entity`] that triggered the observer, could be [`Entity::PLACEHOLDER`].
     pub fn entity(&self) -> Entity {
         self.trigger.entity
@@ -120,7 +144,7 @@ impl<'w, E, B: Bundle> Trigger<'w, E, B> {
     }
 }
 
-impl<'w, E: Debug, B: Bundle> Debug for Trigger<'w, E, B> {
+impl<'w, 'i, E: Debug, B: Bundle> Debug for Trigger<'w, 'i, E, B> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Trigger")
             .field("event", &self.event)
@@ -131,15 +155,15 @@ impl<'w, E: Debug, B: Bundle> Debug for Trigger<'w, E, B> {
     }
 }
 
-impl<'w, E, B: Bundle> Deref for Trigger<'w, E, B> {
+impl<'w, 'i, E, B: Bundle> Deref for Trigger<'w, 'i, E, B> {
     type Target = E;
 
     fn deref(&self) -> &Self::Target {
         self.event
     }
 }
 
-impl<'w, E, B: Bundle> DerefMut for Trigger<'w, E, B> {
+impl<'w, 'i, E, B: Bundle> DerefMut for Trigger<'w, 'i, E, B> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.event
     }

crates/bevy_ecs/src/observer/runner.rs

@@ -374,7 +374,7 @@ fn observer_system_runner<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
     // - system is the same type erased system from above
     unsafe {
         (*system).update_archetype_component_access(world);
-        if (*system).validate_param_unsafe(world) {
+        if (*system).validate_param_unsafe(&trigger, world) {
             (*system).run_unsafe(trigger, world);
             (*system).queue_deferred(world.into_deferred());
         }

crates/bevy_ecs/src/schedule/executor/multi_threaded.rs

@@ -572,7 +572,7 @@ impl ExecutorState {
             // - The caller ensures that `world` has permission to read any data
             //   required by the system.
             // - `update_archetype_component_access` has been called for system.
-            let valid_params = unsafe { system.validate_param_unsafe(world) };
+            let valid_params = unsafe { system.validate_param_unsafe(&(), world) };
             if !valid_params {
                 self.skipped_systems.insert(system_index);
             }
@@ -748,7 +748,7 @@ unsafe fn evaluate_and_fold_conditions(
             // - The caller ensures that `world` has permission to read any data
             //   required by the condition.
             // - `update_archetype_component_access` has been called for condition.
-            if !unsafe { condition.validate_param_unsafe(world) } {
+            if !unsafe { condition.validate_param_unsafe(&(), world) } {
                 return false;
             }
             // SAFETY:

crates/bevy_ecs/src/schedule/executor/simple.rs

@@ -81,7 +81,7 @@ impl SystemExecutor for SimpleExecutor {
 
             let system = &mut schedule.systems[system_index];
             if should_run {
-                let valid_params = system.validate_param(world);
+                let valid_params = system.validate_param(&(), world);
                 should_run &= valid_params;
             }
 
@@ -134,7 +134,7 @@ fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut W
     conditions
         .iter_mut()
         .map(|condition| {
-            if !condition.validate_param(world) {
+            if !condition.validate_param(&(), world) {
                 return false;
             }
             __rust_begin_short_backtrace::readonly_run(&mut **condition, world)

crates/bevy_ecs/src/schedule/executor/single_threaded.rs

@@ -87,7 +87,7 @@ impl SystemExecutor for SingleThreadedExecutor {
 
             let system = &mut schedule.systems[system_index];
             if should_run {
-                let valid_params = system.validate_param(world);
+                let valid_params = system.validate_param(&(), world);
                 should_run &= valid_params;
             }
 
@@ -166,7 +166,7 @@ fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut W
     conditions
         .iter_mut()
         .map(|condition| {
-            if !condition.validate_param(world) {
+            if !condition.validate_param(&(), world) {
                 return false;
             }
             __rust_begin_short_backtrace::readonly_run(&mut **condition, world)

crates/bevy_ecs/src/system/adapter_system.rs

@@ -82,7 +82,7 @@ pub struct IsAdapterSystemMarker;
 impl<Func, S, I, O, M> IntoSystem<Func::In, Func::Out, (IsAdapterSystemMarker, I, O, M)>
     for IntoAdapterSystem<Func, S>
 where
-    Func: Adapt<S::System>,
+    Func: Adapt<S::System, In = I>,
     I: SystemInput,
     S: IntoSystem<I, O, M>,
 {
@@ -118,7 +118,7 @@ where
 impl<Func, S> System for AdapterSystem<Func, S>
 where
     Func: Adapt<S>,
-    S: System,
+    S: System<In = Func::In>,
 {
     type In = Func::In;
     type Out = Func::Out;
@@ -179,9 +179,13 @@ where
     }
 
     #[inline]
-    unsafe fn validate_param_unsafe(&mut self, world: UnsafeWorldCell) -> bool {
+    unsafe fn validate_param_unsafe(
+        &mut self,
+        input: &SystemIn<'_, Self>,
+        world: UnsafeWorldCell,
+    ) -> bool {
         // SAFETY: Delegate to other `System` implementations.
-        unsafe { self.system.validate_param_unsafe(world) }
+        unsafe { self.system.validate_param_unsafe(input, world) }
     }
 
     fn initialize(&mut self, world: &mut crate::prelude::World) {
@@ -214,7 +218,7 @@ where
 unsafe impl<Func, S> ReadOnlySystem for AdapterSystem<Func, S>
 where
     Func: Adapt<S>,
-    S: ReadOnlySystem,
+    S: ReadOnlySystem<In = Func::In>,
 {
 }
 

crates/bevy_ecs/src/system/builder.rs

@@ -4,7 +4,8 @@ use crate::{
     prelude::QueryBuilder,
     query::{QueryData, QueryFilter, QueryState},
     system::{
-        DynSystemParam, DynSystemParamState, Local, ParamSet, Query, SystemMeta, SystemParam,
+        DynSystemParam, DynSystemParamState, Local, ParamSet, Query, SystemInput, SystemMeta,
+        SystemParam,
     },
     world::{
         FilteredResources, FilteredResourcesBuilder, FilteredResourcesMut,
@@ -116,7 +117,7 @@ pub unsafe trait SystemParamBuilder<P: SystemParam>: Sized {
 
     /// Create a [`SystemState`] from a [`SystemParamBuilder`].
     /// To create a system, call [`SystemState::build_system`] on the result.
-    fn build_state(self, world: &mut World) -> SystemState<P> {
+    fn build_state<In: SystemInput>(self, world: &mut World) -> SystemState<P, In> {
         SystemState::from_builder(world, self)
     }
 }

crates/bevy_ecs/src/system/combinator.rs

@@ -88,7 +88,7 @@ use super::{IntoSystem, ReadOnlySystem, System};
     label = "invalid system combination",
     note = "the inputs and outputs of `{A}` and `{B}` are not compatible with this combiner"
 )]
-pub trait Combine<A: System, B: System> {
+pub trait Combine<A: System<In = Self::In>, B: System<In = Self::In>> {
     /// The [input](System::In) type for a [`CombinatorSystem`].
     type In: SystemInput;
 
@@ -137,8 +137,8 @@ impl<Func, A, B> CombinatorSystem<Func, A, B> {
 impl<A, B, Func> System for CombinatorSystem<Func, A, B>
 where
     Func: Combine<A, B> + 'static,
-    A: System,
-    B: System,
+    A: System<In = Func::In>,
+    B: System<In = Func::In>,
 {
     type In = Func::In;
     type Out = Func::Out;
@@ -212,9 +212,15 @@ where
     }
 
     #[inline]
-    unsafe fn validate_param_unsafe(&mut self, world: UnsafeWorldCell) -> bool {
+    unsafe fn validate_param_unsafe(
+        &mut self,
+        input: &SystemIn<'_, Self>,
+        world: UnsafeWorldCell,
+    ) -> bool {
         // SAFETY: Delegate to other `System` implementations.
-        unsafe { self.a.validate_param_unsafe(world) && self.b.validate_param_unsafe(world) }
+        unsafe {
+            self.a.validate_param_unsafe(input, world) && self.b.validate_param_unsafe(input, world)
+        }
     }
 
     fn initialize(&mut self, world: &mut World) {
@@ -259,8 +265,8 @@ where
 unsafe impl<Func, A, B> ReadOnlySystem for CombinatorSystem<Func, A, B>
 where
     Func: Combine<A, B> + 'static,
-    A: ReadOnlySystem,
-    B: ReadOnlySystem,
+    A: ReadOnlySystem<In = Func::In>,
+    B: ReadOnlySystem<In = Func::In>,
 {
 }
 
@@ -431,13 +437,21 @@ where
         self.b.queue_deferred(world);
     }
 
-    unsafe fn validate_param_unsafe(&mut self, world: UnsafeWorldCell) -> bool {
+    unsafe fn validate_param_unsafe(
+        &mut self,
+        input: &SystemIn<'_, Self>,
+        world: UnsafeWorldCell,
+    ) -> bool {
         // SAFETY: Delegate to other `System` implementations.
-        unsafe { self.a.validate_param_unsafe(world) && self.b.validate_param_unsafe(world) }
+        unsafe {
+            // TODO
+            self.a.validate_param_unsafe(input, world) /* && self.b.validate_param_unsafe(input, world) */
+        }
     }
 
-    fn validate_param(&mut self, world: &World) -> bool {
-        self.a.validate_param(world) && self.b.validate_param(world)
+    fn validate_param(&mut self, input: &SystemIn<'_, Self>, world: &World) -> bool {
+        // TODO
+        self.a.validate_param(input, world) /* && self.b.validate_param(input, world) */
     }
 
     fn initialize(&mut self, world: &mut World) {