get_components_mut

benches/Cargo.toml

@@ -11,6 +11,7 @@ autobenches = false
 # The primary crate that runs and analyzes our benchmarks. This is a regular dependency because the
 # `bench!` macro refers to it in its documentation.
 criterion = { version = "0.7.0", features = ["html_reports"] }
+seq-macro = "0.3.6"
 
 [dev-dependencies]
 # Bevy crates

benches/benches/bevy_ecs/world/mod.rs

@@ -35,5 +35,8 @@ criterion_group!(
     query_get_many::<2>,
     query_get_many::<5>,
     query_get_many::<10>,
+    query_get_components_mut_2,
+    query_get_components_mut_5,
+    query_get_components_mut_10,
     entity_set_build_and_lookup,
 );

benches/benches/bevy_ecs/world/world_get.rs

@@ -1,15 +1,17 @@
+use benches::bench;
 use core::hint::black_box;
 
 use bevy_ecs::{
     bundle::{Bundle, NoBundleEffect},
     component::Component,
     entity::Entity,
     system::{Query, SystemState},
-    world::World,
+    world::{EntityMut, World},
 };
 use criterion::Criterion;
 use rand::{prelude::SliceRandom, SeedableRng};
 use rand_chacha::ChaCha8Rng;
+use seq_macro::seq;
 
 #[derive(Component, Default)]
 #[component(storage = "Table")]
@@ -357,3 +359,64 @@ pub fn query_get_many<const N: usize>(criterion: &mut Criterion) {
         });
     }
 }
+
+macro_rules! query_get_components_mut {
+    ($function_name:ident, $val:literal) => {
+        pub fn $function_name(criterion: &mut Criterion) {
+            let mut group = criterion.benchmark_group(bench!("world_query_get_components_mut"));
+            group.warm_up_time(core::time::Duration::from_millis(500));
+            group.measurement_time(core::time::Duration::from_secs(4));
+
+            for entity_count in RANGE.map(|i| i * 10_000) {
+                seq!(N in 0..$val {
+                    let (mut world, entities) = setup_wide::<(
+                        #(WideTable<N>,)*
+                    )>(entity_count);
+                });
+                let mut query = world.query::<EntityMut>();
+                group.bench_function(format!("{}_components_{entity_count}_entities", $val), |bencher| {
+                    bencher.iter(|| {
+                        for entity in &entities {
+                            seq!(N in 0..$val {
+                                assert!(query
+                                    .get_mut(&mut world, *entity)
+                                    .unwrap()
+                                    .get_components_mut::<(
+                                            #(&mut WideTable<N>,)*
+                                        )>()
+                                        .is_ok());
+                            });
+                        }
+                    });
+                });
+                group.bench_function(
+                    format!("unchecked_{}_components_{entity_count}_entities", $val),
+                    |bencher| {
+                        bencher.iter(|| {
+                            for entity in &entities {
+                                // SAFETY: no duplicate components are listed
+                                unsafe {
+                                    seq!(N in 0..$val {
+                                        assert!(query
+                                            .get_mut(&mut world, *entity)
+                                            .unwrap()
+                                            .get_components_mut_unchecked::<(
+                                                    #(&mut WideTable<N>,)*
+                                                )>()
+                                                .is_ok());
+                                    });
+                                }
+                            }
+                        });
+                    },
+                );
+            }
+
+            group.finish();
+        }
+    };
+}
+
+query_get_components_mut!(query_get_components_mut_2, 2);
+query_get_components_mut!(query_get_components_mut_5, 5);
+query_get_components_mut!(query_get_components_mut_10, 10);

crates/bevy_ecs/macros/src/query_data.rs

@@ -61,6 +61,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
     let path = bevy_ecs_path();
 
     let user_generics = ast.generics.clone();
+    let user_generics_ty_params = user_generics.type_params().map(|p| p.ident.clone());
     let (user_impl_generics, user_ty_generics, user_where_clauses) = user_generics.split_for_impl();
     let user_generics_with_world = {
         let mut generics = ast.generics.clone();
@@ -267,6 +268,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                             #(#field_members: <#read_only_field_types>::fetch(&_state.#field_aliases, &mut _fetch.#field_aliases, _entity, _table_row)?,)*
                         })
                     }
+
+                    fn iter_access<'c>(
+                        components: &'c #path::component::Components,
+                        index: &mut usize
+                    ) -> impl core::iter::Iterator<Item = Option<#path::query::EcsAccessType>> + use<'c, #(#user_generics_ty_params,)*> {
+                        core::iter::empty() #(.chain(<#field_types>::iter_access(components, index)))*
+                    }
                 }
 
                 impl #user_impl_generics #path::query::ReleaseStateQueryData
@@ -293,6 +301,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
 
         let is_read_only = !attributes.is_mutable;
 
+        let user_generics_ty_params = user_generics.type_params().map(|p| p.ident.clone());
         quote! {
             /// SAFETY: we assert fields are readonly below
             unsafe impl #user_impl_generics #path::query::QueryData
@@ -332,6 +341,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                         #(#field_members: <#field_types>::fetch(&_state.#field_aliases, &mut _fetch.#field_aliases, _entity, _table_row)?,)*
                     })
                 }
+
+                fn iter_access<'c>(
+                    components: &'c #path::component::Components,
+                    index: &mut usize
+                ) -> impl core::iter::Iterator<Item = Option<#path::query::EcsAccessType>> + use<'c, #(#user_generics_ty_params,)*> {
+                    core::iter::empty() #(.chain(<#field_types>::iter_access(components, index)))*
+                }
             }
 
             impl #user_impl_generics #path::query::ReleaseStateQueryData

crates/bevy_ecs/src/event/trigger.rs

@@ -301,7 +301,7 @@ unsafe impl<
                 return;
             }
             if let Ok(entity) = world.get_entity(current_entity)
-                && let Some(item) = entity.get_components::<T>()
+                && let Ok(item) = entity.get_components::<T>()
                 && let Some(traverse_to) = T::traverse(item, event)
             {
                 current_entity = traverse_to;