Expose system accesses and filters in BRP schedule.graph

Author: Zeophlite

crates/bevy_dev_tools/src/schedule_data/serde.rs

@@ -71,6 +71,10 @@ pub struct ScheduleData {
     pub conflicts: Vec<SystemConflict>,
 }
 
+/// A newtype for the index of a component.
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord, Hash)]
+pub struct ComponentIndex(pub u32);
+
 /// Data about a component type.
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct ComponentData {
@@ -89,7 +93,65 @@ pub struct SystemData {
     pub exclusive: bool,
     /// Whether this system has deferred buffers to apply.
     pub deferred: bool,
-    // TODO: Store the conditions specific to this system.
+
+    /// Combined access for the system
+    pub combined_access: AccessData,
+    /// Filtered accesses for the system
+    pub filtered_accesses: Vec<FilteredAccessData>,
+}
+
+/// Access wrapper
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Default)]
+pub struct AccessData {
+    read_and_writes: Vec<u32>,
+    writes: Vec<u32>,
+    read_and_writes_inverted: bool,
+    writes_inverted: bool,
+    archetypal: Vec<u32>,
+}
+
+impl AccessData {
+    fn new(value: &bevy_ecs::query::Access, trace: &mut ComponentTrace) -> Self {
+        Self {
+            read_and_writes: trace.get_indexes(value.read_and_writes().iter()),
+            writes: trace.get_indexes(value.writes().iter()),
+            read_and_writes_inverted: value.read_and_writes_inverted(),
+            writes_inverted: value.writes_inverted(),
+            archetypal: trace.get_indexes(value.archetypal().iter()),
+        }
+    }
+}
+
+/// `AccessFilters` wrapper
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Default)]
+pub struct AccessFiltersData {
+    with: Vec<u32>,
+    without: Vec<u32>,
+}
+
+/// `FilteredAccess` wrapper
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Default)]
+pub struct FilteredAccessData {
+    access: AccessData,
+    required: Vec<u32>,
+    filter_sets: Vec<AccessFiltersData>,
+}
+
+impl FilteredAccessData {
+    fn new(value: &bevy_ecs::query::FilteredAccess, trace: &mut ComponentTrace) -> Self {
+        Self {
+            access: AccessData::new(value.access(), trace),
+            required: trace.get_indexes(value.required().iter()),
+            filter_sets: value
+                .filter_sets()
+                .iter()
+                .map(|f| AccessFiltersData {
+                    with: trace.get_indexes(f.with().iter()),
+                    without: trace.get_indexes(f.without().iter()),
+                })
+                .collect(),
+        }
+    }
 }
 
 /// Data about a particular system set.
@@ -145,6 +207,49 @@ pub enum AccessConflict {
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
 pub struct SystemSetIndex(pub u32);
 
+// Helper to build the components used by systems in this schedule
+struct ComponentTrace<'a> {
+    world_components: &'a Components,
+    component_id_to_index: HashMap<ComponentId, usize>,
+    components: Vec<ComponentData>,
+}
+
+impl<'a> ComponentTrace<'a> {
+    fn with_world_components(world_components: &'a Components) -> Self {
+        Self {
+            world_components,
+            component_id_to_index: HashMap::new(),
+            components: vec![],
+        }
+    }
+
+    fn get_index(&mut self, id: ComponentId) -> u32 {
+        match self.component_id_to_index.entry(id) {
+            Entry::Occupied(entry) => *entry.get() as _,
+            Entry::Vacant(entry) => {
+                let component = self
+                    .world_components
+                    .get_info(id)
+                    .expect("the component has already been registered by the system");
+
+                self.components.push(ComponentData {
+                    name: format!("{}", component.name()),
+                });
+
+                *entry.insert(self.components.len() - 1) as _
+            }
+        }
+    }
+
+    fn get_indexes(&mut self, ids: impl Iterator<Item = ComponentId>) -> Vec<u32> {
+        ids.map(|id| self.get_index(id)).collect()
+    }
+
+    fn get_indexes3<'b>(&mut self, ids: impl Iterator<Item = &'b ComponentId>) -> Vec<u32> {
+        ids.map(|id| self.get_index(*id)).collect()
+    }
+}
+
 impl ScheduleData {
     /// Creates the data from the underlying [`Schedule`].
     ///
@@ -154,6 +259,8 @@ impl ScheduleData {
         world_components: &Components,
         build_metadata: Option<&ScheduleBuildMetadata>,
     ) -> Result<Self, ExtractAppDataError> {
+        let mut component_trace = ComponentTrace::with_world_components(world_components);
+
         let graph = schedule.graph();
 
         let mut system_key_to_index = HashMap::new();
@@ -169,14 +276,20 @@ impl ScheduleData {
         }
 
         let systems = schedule
-            .systems()
+            .systems_with_access()
             .map_err(|_| {
                 ExtractAppDataError::ScheduleNotInitialized(format!("{:?}", schedule.label()))
             })?
             .enumerate()
-            .map(|(index, (key, system))| {
+            .map(|(index, (key, system_with_access))| {
                 system_key_to_index.insert(key, index);
 
+                let system = system_with_access.system();
+                let access = system_with_access.access();
+
+                let combined_access = access.combined_access();
+                let filtered_accesses = access.filtered_accesses();
+
                 let flags = system.flags();
 
                 SystemData {
@@ -185,6 +298,11 @@ impl ScheduleData {
                         == core::any::TypeId::of::<ApplyDeferred>(),
                     exclusive: flags.contains(SystemStateFlags::EXCLUSIVE),
                     deferred: flags.contains(SystemStateFlags::DEFERRED),
+                    combined_access: AccessData::new(combined_access, &mut component_trace),
+                    filtered_accesses: filtered_accesses
+                        .iter()
+                        .map(|fa| FilteredAccessData::new(fa, &mut component_trace))
+                        .collect(),
                 }
             })
             .collect();
@@ -258,9 +376,6 @@ impl ScheduleData {
             );
         }
 
-        let mut component_id_to_index = HashMap::<ComponentId, usize>::new();
-        let mut components = vec![];
-
         let conflicts = graph
             .conflicting_systems()
             .iter()
@@ -279,29 +394,14 @@ impl ScheduleData {
                         // The systems conflict on the world if there's no particular component IDs.
                         AccessConflict::World
                     } else {
-                        AccessConflict::Components(
-                            conflicts
-                                .iter()
-                                .map(|id| match component_id_to_index.entry(*id) {
-                                    Entry::Occupied(entry) => *entry.get() as _,
-                                    Entry::Vacant(entry) => {
-                                        let component = world_components.get_info(*id).expect(
-                                    "the component has already been registered by the system",
-                                );
-
-                                        components.push(ComponentData {
-                                            name: format!("{}", component.name()),
-                                        });
-                                        *entry.insert(components.len() - 1) as _
-                                    }
-                                })
-                                .collect(),
-                        )
+                        AccessConflict::Components(component_trace.get_indexes3(conflicts.iter()))
                     },
                 }
             })
             .collect();
 
+        let components = component_trace.components;
+
         Ok(Self {
             name: format!("{:?}", schedule.label()),
             components,
@@ -337,8 +437,9 @@ pub mod tests {
     use bevy_platform::collections::HashMap;
 
     use crate::schedule_data::serde::{
-        AccessConflict, AppData, ComponentData, ExtractAppDataError, ScheduleData, ScheduleIndex,
-        SystemConflict, SystemData, SystemSetData, SystemSetIndex,
+        AccessConflict, AccessData, AppData, ComponentData, ExtractAppDataError,
+        FilteredAccessData, ScheduleData, ScheduleIndex, SystemConflict, SystemData, SystemSetData,
+        SystemSetIndex,
     };
 
     fn app_data_from_app(app: &mut App) -> Result<AppData, ExtractAppDataError> {
@@ -517,6 +618,8 @@ pub mod tests {
             apply_deferred: false,
             exclusive: false,
             deferred: false,
+            combined_access: AccessData::default(),
+            filtered_accesses: vec![],
         }
     }
 
@@ -704,18 +807,24 @@ pub mod tests {
                     apply_deferred: false,
                     exclusive: false,
                     deferred: true,
+                    combined_access: AccessData::default(),
+                    filtered_accesses: vec![],
                 },
                 SystemData {
                     name: "a1".into(),
                     apply_deferred: false,
                     exclusive: false,
                     deferred: true,
+                    combined_access: AccessData::default(),
+                    filtered_accesses: vec![],
                 },
                 SystemData {
                     name: "apply_deferred".into(),
                     apply_deferred: true,
                     exclusive: true,
                     deferred: false,
+                    combined_access: AccessData::default(),
+                    filtered_accesses: vec![],
                 },
                 simple_system("b0"),
                 simple_system("b1"),

crates/bevy_ecs/src/query/access.rs

@@ -395,6 +395,30 @@ impl Access {
         AccessConflicts::Individual(conflicts)
     }
 
+    /// All accessed components, or forbidden components if
+    /// `Self::component_read_and_writes_inverted` is set.
+    pub fn read_and_writes(&self) -> &ComponentIdSet {
+        &self.read_and_writes
+    }
+
+    /// All exclusively-accessed components, or components that may not be
+    /// exclusively accessed if `Self::component_writes_inverted` is set.
+    pub fn writes(&self) -> &ComponentIdSet {
+        &self.writes
+    }
+
+    /// Is `true` if this component can read all components *except* those
+    /// present in `Self::read_and_writes`.
+    pub fn read_and_writes_inverted(&self) -> bool {
+        self.read_and_writes_inverted
+    }
+
+    /// Is `true` if this component can write to all components *except* those
+    /// present in `Self::writes`.
+    pub fn writes_inverted(&self) -> bool {
+        self.writes_inverted
+    }
+
     /// Returns the indices of the components that this has an archetypal access to.
     ///
     /// These are components whose values are not accessed (and thus will never cause conflicts),

crates/bevy_ecs/src/schedule/node.rs

@@ -55,6 +55,11 @@ impl SystemWithAccess {
     pub fn system(&self) -> &ScheduleSystem {
         &self.system
     }
+
+    /// Access
+    pub fn access(&self) -> &FilteredAccessSet {
+        &self.access
+    }
 }
 
 impl System for SystemWithAccess {

crates/bevy_ecs/src/schedule/schedule.rs

@@ -708,6 +708,25 @@ impl Schedule {
         Ok(iter)
     }
 
+    /// Sys
+    pub fn systems_with_access(
+        &self,
+    ) -> Result<impl Iterator<Item = (SystemKey, &SystemWithAccess)> + Sized, ScheduleNotInitialized>
+    {
+        if !self.executor_initialized {
+            return Err(ScheduleNotInitialized);
+        }
+
+        let iter = self
+            .executable
+            .system_ids
+            .iter()
+            .zip(&self.executable.systems)
+            .map(|(&node_id, system)| (node_id, system));
+
+        Ok(iter)
+    }
+
     /// Returns the number of systems in this schedule.
     pub fn systems_len(&self) -> usize {
         if !self.executor_initialized {