Dynamic queries and builder API

Cargo.toml

@@ -1300,6 +1300,17 @@ description = "Groups commonly used compound queries and query filters into a si
 category = "ECS (Entity Component System)"
 wasm = false
 
+[[example]]
+name = "dynamic"
+path = "examples/ecs/dynamic.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.dynamic]
+name = "Dynamic ECS"
+description = "Dynamically create components, spawn entities with those components and query those components"
+category = "ECS (Entity Component System)"
+wasm = false
+
 [[example]]
 name = "event"
 path = "examples/ecs/event.rs"

crates/bevy_ecs/macros/src/fetch.rs

@@ -336,22 +336,18 @@ pub fn derive_world_query_impl(input: TokenStream) -> TokenStream {
                     #( <#field_types>::update_component_access(&state.#named_field_idents, _access); )*
                 }
 
-                fn update_archetype_component_access(
-                    state: &Self::State,
-                    _archetype: &#path::archetype::Archetype,
-                    _access: &mut #path::query::Access<#path::archetype::ArchetypeComponentId>
-                ) {
-                    #(
-                        <#field_types>::update_archetype_component_access(&state.#named_field_idents, _archetype, _access);
-                    )*
-                }
-
                 fn init_state(world: &mut #path::world::World) -> #state_struct_name #user_ty_generics {
                     #state_struct_name {
                         #(#named_field_idents: <#field_types>::init_state(world),)*
                     }
                 }
 
+                fn get_state(world: &#path::world::World) -> Option<#state_struct_name #user_ty_generics> {
+                    Some(#state_struct_name {
+                        #(#named_field_idents: <#field_types>::get_state(world)?,)*
+                    })
+                }
+
                 fn matches_component_set(state: &Self::State, _set_contains_id: &impl Fn(#path::component::ComponentId) -> bool) -> bool {
                     true #(&& <#field_types>::matches_component_set(&state.#named_field_idents, _set_contains_id))*
                 }

crates/bevy_ecs/src/lib.rs

@@ -39,7 +39,7 @@ pub mod prelude {
         component::Component,
         entity::Entity,
         event::{Event, EventReader, EventWriter, Events},
-        query::{Added, AnyOf, Changed, Has, Or, QueryState, With, Without},
+        query::{Added, AnyOf, Changed, Has, Or, QueryBuilder, QueryState, With, Without},
         removal_detection::RemovedComponents,
         schedule::{
             apply_deferred, apply_state_transition, common_conditions::*, Condition,

crates/bevy_ecs/src/query/access.rs

@@ -157,6 +157,12 @@ impl<T: SparseSetIndex> Access<T> {
         self.writes_all
     }
 
+    /// Removes all writes.
+    pub fn clear_writes(&mut self) {
+        self.writes_all = false;
+        self.writes.clear();
+    }
+
     /// Removes all accesses.
     pub fn clear(&mut self) {
         self.reads_all = false;
@@ -198,6 +204,33 @@ impl<T: SparseSetIndex> Access<T> {
             && other.writes.is_disjoint(&self.reads_and_writes)
     }
 
+    /// Returns `true` if the set is a subset of another, i.e. `other` contains
+    /// at least all the values in `self`.
+    pub fn is_subset(&self, other: &Access<T>) -> bool {
+        if self.writes_all {
+            return other.writes_all;
+        }
+
+        if other.writes_all {
+            return true;
+        }
+
+        if self.reads_all {
+            return other.reads_all;
+        }
+
+        if other.reads_all {
+            return self.writes.is_subset(&other.writes);
+        }
+
+        let reads = self
+            .reads_and_writes
+            .difference(&self.writes)
+            .collect::<FixedBitSet>();
+
+        reads.is_subset(&other.reads_and_writes) && self.writes.is_subset(&other.writes)
+    }
+
     /// Returns a vector of elements that the access and `other` cannot access at the same time.
     pub fn get_conflicts(&self, other: &Access<T>) -> Vec<T> {
         let mut conflicts = FixedBitSet::default();
@@ -267,16 +300,18 @@ impl<T: SparseSetIndex> Access<T> {
 /// See comments the [`WorldQuery`](super::WorldQuery) impls of [`AnyOf`](super::AnyOf)/`Option`/[`Or`](super::Or) for more information.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct FilteredAccess<T: SparseSetIndex> {
-    access: Access<T>,
+    pub(crate) access: Access<T>,
+    pub(crate) required: FixedBitSet,
     // An array of filter sets to express `With` or `Without` clauses in disjunctive normal form, for example: `Or<(With<A>, With<B>)>`.
     // Filters like `(With<A>, Or<(With<B>, Without<C>)>` are expanded into `Or<((With<A>, With<B>), (With<A>, Without<C>))>`.
-    filter_sets: Vec<AccessFilters<T>>,
+    pub(crate) filter_sets: Vec<AccessFilters<T>>,
 }
 
 impl<T: SparseSetIndex> Default for FilteredAccess<T> {
     fn default() -> Self {
         Self {
             access: Access::default(),
+            required: FixedBitSet::default(),
             filter_sets: vec![AccessFilters::default()],
         }
     }
@@ -306,15 +341,23 @@ impl<T: SparseSetIndex> FilteredAccess<T> {
     /// Adds access to the element given by `index`.
     pub fn add_read(&mut self, index: T) {
         self.access.add_read(index.clone());
+        self.add_required(index.clone());
         self.and_with(index);
     }
 
     /// Adds exclusive access to the element given by `index`.
     pub fn add_write(&mut self, index: T) {
         self.access.add_write(index.clone());
+        self.add_required(index.clone());
         self.and_with(index);
     }
 
+    fn add_required(&mut self, index: T) {
+        let index = index.sparse_set_index();
+        self.required.grow(index + 1);
+        self.required.insert(index);
+    }
+
     /// Adds a `With` filter: corresponds to a conjunction (AND) operation.
     ///
     /// Suppose we begin with `Or<(With<A>, With<B>)>`, which is represented by an array of two `AccessFilter` instances.
@@ -391,6 +434,7 @@ impl<T: SparseSetIndex> FilteredAccess<T> {
     /// `Or<((With<A>, With<C>), (With<A>, Without<D>), (Without<B>, With<C>), (Without<B>, Without<D>))>`.
     pub fn extend(&mut self, other: &FilteredAccess<T>) {
         self.access.extend(&other.access);
+        self.required.union_with(&other.required);
 
         // We can avoid allocating a new array of bitsets if `other` contains just a single set of filters:
         // in this case we can short-circuit by performing an in-place union for each bitset.
@@ -423,12 +467,18 @@ impl<T: SparseSetIndex> FilteredAccess<T> {
     pub fn write_all(&mut self) {
         self.access.write_all();
     }
+
+    /// Returns `true` if the set is a subset of another, i.e. `other` contains
+    /// at least all the values in `self`.
+    pub fn is_subset(&self, other: &FilteredAccess<T>) -> bool {
+        self.required.is_subset(&other.required) && self.access().is_subset(other.access())
+    }
 }
 
 #[derive(Clone, Eq, PartialEq)]
-struct AccessFilters<T> {
-    with: FixedBitSet,
-    without: FixedBitSet,
+pub(crate) struct AccessFilters<T> {
+    pub(crate) with: FixedBitSet,
+    pub(crate) without: FixedBitSet,
     _index_type: PhantomData<T>,
 }