relations

Author: BoxyUwU

Cargo.toml

@@ -258,6 +258,10 @@ path = "examples/diagnostics/custom_diagnostic.rs"
 name = "ecs_guide"
 path = "examples/ecs/ecs_guide.rs"
 
+[[example]]
+name = "relations_grouping"
+path = "examples/ecs/relations_grouping.rs"
+
 [[example]]
 name = "change_detection"
 path = "examples/ecs/change_detection.rs"

crates/bevy_core/src/time/fixed_timestep.rs

@@ -1,7 +1,7 @@
 use crate::Time;
 use bevy_ecs::{
     archetype::{Archetype, ArchetypeComponentId},
-    component::ComponentId,
+    component::RelationKindId,
     query::Access,
     schedule::ShouldRun,
     system::{IntoSystem, Local, Res, ResMut, System, SystemId},
@@ -160,7 +160,7 @@ impl System for FixedTimestep {
         self.internal_system.archetype_component_access()
     }
 
-    fn component_access(&self) -> &Access<ComponentId> {
+    fn component_access(&self) -> &Access<RelationKindId> {
         self.internal_system.component_access()
     }
 

crates/bevy_ecs/Cargo.toml

@@ -23,6 +23,7 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 bevy_ecs_macros = { path = "macros", version = "0.5.0" }
 
+smallvec = { version = "1.4", features = ["serde"] }
 async-channel = "1.4"
 bitflags = "1.2"
 fixedbitset = "0.4"

crates/bevy_ecs/macros/src/lib.rs

@@ -258,7 +258,17 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
                 fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta) {
                     let (#(#query,)*) = &mut self.0;
                     #(
-                        #query.new_archetype(archetype);
+                        for (relation_filter, cache) in #query.relation_filter_accesses.iter_mut() {
+                            QueryState::<#query, #filter>::new_archetype(
+                                &#query.fetch_state,
+                                &#query.filter_state,
+                                &mut #query.archetype_component_access,
+                                &*relation_filter,
+                                cache,
+                                archetype
+                            );
+                        }
+
                         system_meta
                             .archetype_component_access
                             .extend(&#query.archetype_component_access);
@@ -280,7 +290,7 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
                     world: &'a World,
                     change_tick: u32,
                 ) -> Self::Item {
-                    let (#(#query,)*) = &state.0;
+                    let (#(#query,)*) = &mut state.0;
                     QuerySet((#(Query::new(world, #query, system_meta.last_change_tick, change_tick),)*))
                 }
             }

crates/bevy_ecs/src/archetype.rs

@@ -1,12 +1,14 @@
+use bevy_utils::HashMap;
+use bevy_utils::StableHashMap;
+
 use crate::{
     bundle::BundleId,
-    component::{ComponentId, StorageType},
+    component::{RelationKindId, StorageType},
     entity::{Entity, EntityLocation},
     storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
 };
 use std::{
     borrow::Cow,
-    collections::HashMap,
     hash::Hash,
     ops::{Index, IndexMut},
 };
@@ -124,54 +126,73 @@ pub struct Archetype {
     entities: Vec<Entity>,
     edges: Edges,
     table_info: TableInfo,
-    table_components: Cow<'static, [ComponentId]>,
-    sparse_set_components: Cow<'static, [ComponentId]>,
-    pub(crate) unique_components: SparseSet<ComponentId, Column>,
-    pub(crate) components: SparseSet<ComponentId, ArchetypeComponentInfo>,
+    table_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
+    sparse_set_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
+    pub(crate) unique_components: SparseSet<RelationKindId, Column>,
+    pub(crate) components: SparseSet<RelationKindId, ArchetypeComponentInfo>,
+    pub(crate) relations: SparseSet<RelationKindId, StableHashMap<Entity, ArchetypeComponentInfo>>,
 }
 
 impl Archetype {
     pub fn new(
         id: ArchetypeId,
         table_id: TableId,
-        table_components: Cow<'static, [ComponentId]>,
-        sparse_set_components: Cow<'static, [ComponentId]>,
+        table_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
+        sparse_set_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
         table_archetype_components: Vec<ArchetypeComponentId>,
         sparse_set_archetype_components: Vec<ArchetypeComponentId>,
     ) -> Self {
+        // FIXME(Relationships) sort out this capacity weirdness
         let mut components =
             SparseSet::with_capacity(table_components.len() + sparse_set_components.len());
-        for (component_id, archetype_component_id) in
+        let mut relations = SparseSet::new();
+        for ((kind_id, target), archetype_component_id) in
             table_components.iter().zip(table_archetype_components)
         {
-            components.insert(
-                *component_id,
-                ArchetypeComponentInfo {
-                    storage_type: StorageType::Table,
-                    archetype_component_id,
-                },
-            );
+            let arch_comp_info = ArchetypeComponentInfo {
+                storage_type: StorageType::Table,
+                archetype_component_id,
+            };
+
+            match target {
+                None => {
+                    components.insert(*kind_id, arch_comp_info);
+                }
+                Some(target) => {
+                    let set = relations.get_or_insert_with(*kind_id, StableHashMap::default);
+                    set.insert(*target, arch_comp_info);
+                }
+            };
         }
 
-        for (component_id, archetype_component_id) in sparse_set_components
+        for ((kind_id, target), archetype_component_id) in sparse_set_components
             .iter()
             .zip(sparse_set_archetype_components)
         {
-            components.insert(
-                *component_id,
-                ArchetypeComponentInfo {
-                    storage_type: StorageType::SparseSet,
-                    archetype_component_id,
-                },
-            );
+            let arch_comp_info = ArchetypeComponentInfo {
+                storage_type: StorageType::SparseSet,
+                archetype_component_id,
+            };
+
+            match target {
+                None => {
+                    components.insert(*kind_id, arch_comp_info);
+                }
+                Some(target) => {
+                    let set = relations.get_or_insert_with(*kind_id, StableHashMap::default);
+                    set.insert(*target, arch_comp_info);
+                }
+            };
         }
+
         Self {
             id,
             table_info: TableInfo {
                 id: table_id,
                 entity_rows: Default::default(),
             },
             components,
+            relations,
             table_components,
             sparse_set_components,
             unique_components: SparseSet::new(),
@@ -201,28 +222,38 @@ impl Archetype {
     }
 
     #[inline]
-    pub fn table_components(&self) -> &[ComponentId] {
+    pub fn table_components(&self) -> &[(RelationKindId, Option<Entity>)] {
         &self.table_components
     }
 
     #[inline]
-    pub fn sparse_set_components(&self) -> &[ComponentId] {
+    pub fn sparse_set_components(&self) -> &[(RelationKindId, Option<Entity>)] {
         &self.sparse_set_components
     }
 
     #[inline]
-    pub fn unique_components(&self) -> &SparseSet<ComponentId, Column> {
+    pub fn unique_components(&self) -> &SparseSet<RelationKindId, Column> {
         &self.unique_components
     }
 
     #[inline]
-    pub fn unique_components_mut(&mut self) -> &mut SparseSet<ComponentId, Column> {
+    pub fn unique_components_mut(&mut self) -> &mut SparseSet<RelationKindId, Column> {
         &mut self.unique_components
     }
 
+    // FIXME(Relationships) this also yields relations which feels weird but also needed
     #[inline]
-    pub fn components(&self) -> impl Iterator<Item = ComponentId> + '_ {
-        self.components.indices()
+    pub fn components(&self) -> impl Iterator<Item = (RelationKindId, Option<Entity>)> + '_ {
+        self.components
+            .indices()
+            .map(|kind| (kind, None))
+            .chain(self.relations.indices().flat_map(move |kind_id| {
+                self.relations
+                    .get(kind_id)
+                    .unwrap()
+                    .keys()
+                    .map(move |target| (kind_id, Some(*target)))
+            }))
     }
 
     #[inline]
@@ -289,25 +320,51 @@ impl Archetype {
     }
 
     #[inline]
-    pub fn contains(&self, component_id: ComponentId) -> bool {
-        self.components.contains(component_id)
+    pub fn contains(&self, relation_kind: RelationKindId, relation_target: Option<Entity>) -> bool {
+        match relation_target {
+            None => self.components.contains(relation_kind),
+            Some(target) => self
+                .relations
+                .get(relation_kind)
+                .map(|set| set.get(&target))
+                .flatten()
+                .is_some(),
+        }
     }
 
+    // FIXME(Relationships) technically the target is unnecessary here as all `KindId` have the same storage type
     #[inline]
-    pub fn get_storage_type(&self, component_id: ComponentId) -> Option<StorageType> {
-        self.components
-            .get(component_id)
-            .map(|info| info.storage_type)
+    pub fn get_storage_type(
+        &self,
+        relation_kind: RelationKindId,
+        relation_target: Option<Entity>,
+    ) -> Option<StorageType> {
+        match relation_target {
+            None => self.components.get(relation_kind),
+            Some(target) => self
+                .relations
+                .get(relation_kind)
+                .map(|set| set.get(&target))
+                .flatten(),
+        }
+        .map(|info| info.storage_type)
     }
 
     #[inline]
     pub fn get_archetype_component_id(
         &self,
-        component_id: ComponentId,
+        relation_kind: RelationKindId,
+        relation_target: Option<Entity>,
     ) -> Option<ArchetypeComponentId> {
-        self.components
-            .get(component_id)
-            .map(|info| info.archetype_component_id)
+        match relation_target {
+            None => self.components.get(relation_kind),
+            Some(target) => self
+                .relations
+                .get(relation_kind)
+                .map(|set| set.get(&target))
+                .flatten(),
+        }
+        .map(|info| info.archetype_component_id)
     }
 }
 
@@ -329,8 +386,8 @@ impl ArchetypeGeneration {
 
 #[derive(Hash, PartialEq, Eq)]
 pub struct ArchetypeIdentity {
-    table_components: Cow<'static, [ComponentId]>,
-    sparse_set_components: Cow<'static, [ComponentId]>,
+    table_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
+    sparse_set_components: Cow<'static, [(RelationKindId, Option<Entity>)]>,
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
@@ -453,6 +510,10 @@ impl Archetypes {
         a: ArchetypeId,
         b: ArchetypeId,
     ) -> (&mut Archetype, &mut Archetype) {
+        if a.0 == b.0 {
+            panic!("both indexes were the same");
+        }
+
         if a.index() > b.index() {
             let (b_slice, a_slice) = self.archetypes.split_at_mut(a.index());
             (&mut a_slice[0], &mut b_slice[b.index()])
@@ -475,8 +536,8 @@ impl Archetypes {
     pub(crate) fn get_id_or_insert(
         &mut self,
         table_id: TableId,
-        table_components: Vec<ComponentId>,
-        sparse_set_components: Vec<ComponentId>,
+        table_components: Vec<(RelationKindId, Option<Entity>)>,
+        sparse_set_components: Vec<(RelationKindId, Option<Entity>)>,
     ) -> ArchetypeId {
         let table_components = Cow::from(table_components);
         let sparse_set_components = Cow::from(sparse_set_components);