Entity Relations :thepr:

Co-authored-by: Patrik Buhring <patrikbuhring@gmail.com>

Cargo.toml

@@ -261,6 +261,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 = "component_change_detection"
 path = "examples/ecs/component_change_detection.rs"

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"
 fixedbitset = "0.4"
 fxhash = "0.2"

crates/bevy_ecs/macros/src/lib.rs

@@ -128,7 +128,10 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             });
         } else {
             field_component_ids.push(quote! {
-                component_ids.push(components.get_or_insert_id::<#field_type>());
+                component_ids.push(
+                    components
+                    .component_id_or_insert::<#field_type>()
+                );
             });
             field_get_components.push(quote! {
                 func((&mut self.#field as *mut #field_type).cast::<u8>());
@@ -260,7 +263,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 (target_filter, cache) in #query.target_filter_accesses.iter_mut() {
+                            QueryState::<#query, #filter>::new_archetype(
+                                &#query.fetch_state,
+                                &#query.filter_state,
+                                &mut #query.archetype_component_access,
+                                &*target_filter,
+                                cache,
+                                archetype
+                            );
+                        }
+
                         system_meta
                             .archetype_component_access
                             .extend(&#query.archetype_component_access);
@@ -282,7 +295,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},
     entity::{Entity, EntityLocation},
-    storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
+    storage::{Column, SparseSet, SparseSetIndex, TableId},
 };
 use std::{
     borrow::Cow,
-    collections::HashMap,
     hash::Hash,
     ops::{Index, IndexMut},
 };
@@ -48,15 +50,41 @@ pub struct AddBundle {
 
 #[derive(Default)]
 pub struct Edges {
-    pub add_bundle: SparseArray<BundleId, AddBundle>,
-    pub remove_bundle: SparseArray<BundleId, Option<ArchetypeId>>,
-    pub remove_bundle_intersection: SparseArray<BundleId, Option<ArchetypeId>>,
+    pub add_bundle: HashMap<BundleId, AddBundle>,
+    pub remove_bundle: HashMap<BundleId, Option<ArchetypeId>>,
+    pub remove_bundle_intersection: HashMap<BundleId, Option<ArchetypeId>>,
 }
 
 impl Edges {
+    pub fn debug_ram_usage(&self) -> usize {
+        use std::mem::size_of;
+
+        let mut size = size_of::<Edges>();
+
+        let usage_of_hm = |cap: usize, k, v| (cap * 11 / 10).next_power_of_two() * (k + v + 8);
+
+        size += usage_of_hm(
+            self.add_bundle.capacity(),
+            size_of::<BundleId>(),
+            size_of::<AddBundle>(),
+        );
+        size += usage_of_hm(
+            self.remove_bundle.capacity(),
+            size_of::<BundleId>(),
+            size_of::<Option<ArchetypeId>>(),
+        );
+        size += usage_of_hm(
+            self.remove_bundle_intersection.capacity(),
+            size_of::<BundleId>(),
+            size_of::<Option<ArchetypeId>>(),
+        );
+
+        size
+    }
+
     #[inline]
     pub fn get_add_bundle(&self, bundle_id: BundleId) -> Option<&AddBundle> {
-        self.add_bundle.get(bundle_id)
+        self.add_bundle.get(&bundle_id)
     }
 
     #[inline]
@@ -77,7 +105,7 @@ impl Edges {
 
     #[inline]
     pub fn get_remove_bundle(&self, bundle_id: BundleId) -> Option<Option<ArchetypeId>> {
-        self.remove_bundle.get(bundle_id).cloned()
+        self.remove_bundle.get(&bundle_id).cloned()
     }
 
     #[inline]
@@ -90,7 +118,7 @@ impl Edges {
         &self,
         bundle_id: BundleId,
     ) -> Option<Option<ArchetypeId>> {
-        self.remove_bundle_intersection.get(bundle_id).cloned()
+        self.remove_bundle_intersection.get(&bundle_id).cloned()
     }
 
     #[inline]
@@ -124,54 +152,103 @@ pub struct Archetype {
     entities: Vec<Entity>,
     edges: Edges,
     table_info: TableInfo,
-    table_components: Cow<'static, [ComponentId]>,
-    sparse_set_components: Cow<'static, [ComponentId]>,
+    table_components: Cow<'static, [(ComponentId, Option<Entity>)]>,
+    sparse_set_components: Cow<'static, [(ComponentId, Option<Entity>)]>,
     pub(crate) unique_components: SparseSet<ComponentId, Column>,
     pub(crate) components: SparseSet<ComponentId, ArchetypeComponentInfo>,
+    pub(crate) relations: SparseSet<ComponentId, StableHashMap<Entity, ArchetypeComponentInfo>>,
 }
 
 impl Archetype {
+    pub fn debug_ram_usage(&self) -> (usize, usize) {
+        use std::mem::size_of;
+        let mut size = size_of::<Archetype>();
+
+        if let Cow::Owned(owned) = &self.table_components {
+            size += size_of::<(ComponentId, Option<Entity>)>() * owned.len();
+        }
+        if let Cow::Owned(owned) = &self.sparse_set_components {
+            size += size_of::<(ComponentId, Option<Entity>)>() * owned.len();
+        }
+
+        size += size_of::<ArchetypeComponentInfo>() * self.components.dense_len();
+        size += size_of::<ComponentId>() * self.components.indices_len();
+        size += size_of::<Option<usize>>() * self.components.sparse_len();
+
+        size += size_of::<ComponentId>() * self.relations.indices_len();
+        size += size_of::<Option<usize>>() * self.relations.sparse_len();
+
+        for v in self.relations.values() {
+            let cap = v.capacity();
+            let usage = (cap * 11 / 10).next_power_of_two()
+                * (size_of::<Entity>() + size_of::<ArchetypeComponentInfo>() + 8);
+            size += usage;
+        }
+
+        size += size_of::<Entity>() * self.entities.len();
+
+        (size, self.edges.debug_ram_usage())
+    }
+
     pub fn new(
         id: ArchetypeId,
         table_id: TableId,
-        table_components: Cow<'static, [ComponentId]>,
-        sparse_set_components: Cow<'static, [ComponentId]>,
+        table_components: Cow<'static, [(ComponentId, Option<Entity>)]>,
+        sparse_set_components: Cow<'static, [(ComponentId, 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 ((component_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(*component_id, arch_comp_info);
+                }
+                Some(target) => {
+                    let set = relations.get_or_insert_with(*component_id, StableHashMap::default);
+                    set.insert(*target, arch_comp_info);
+                }
+            };
         }
 
-        for (component_id, archetype_component_id) in sparse_set_components
+        for ((component_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(*component_id, arch_comp_info);
+                }
+                Some(target) => {
+                    let set = relations.get_or_insert_with(*component_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,12 +278,12 @@ impl Archetype {
     }
 
     #[inline]
-    pub fn table_components(&self) -> &[ComponentId] {
+    pub fn table_components(&self) -> &[(ComponentId, Option<Entity>)] {
         &self.table_components
     }
 
     #[inline]
-    pub fn sparse_set_components(&self) -> &[ComponentId] {
+    pub fn sparse_set_components(&self) -> &[(ComponentId, Option<Entity>)] {
         &self.sparse_set_components
     }
 
@@ -221,8 +298,17 @@ impl Archetype {
     }
 
     #[inline]
-    pub fn components(&self) -> impl Iterator<Item = ComponentId> + '_ {
-        self.components.indices()
+    pub fn components(&self) -> impl Iterator<Item = (ComponentId, Option<Entity>)> + '_ {
+        self.components
+            .indices()
+            .map(|kind| (kind, None))
+            .chain(self.relations.indices().flat_map(move |component_id| {
+                self.relations
+                    .get(component_id)
+                    .unwrap()
+                    .keys()
+                    .map(move |target| (component_id, Some(*target)))
+            }))
     }
 
     #[inline]
@@ -289,25 +375,50 @@ impl Archetype {
     }
 
     #[inline]
-    pub fn contains(&self, component_id: ComponentId) -> bool {
-        self.components.contains(component_id)
+    pub fn contains(&self, component_id: ComponentId, target: Option<Entity>) -> bool {
+        match target {
+            None => self.components.contains(component_id),
+            Some(target) => self
+                .relations
+                .get(component_id)
+                .map(|set| set.contains_key(&target))
+                .unwrap_or(false),
+        }
     }
 
+    // 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,
+        component_id: ComponentId,
+        target: Option<Entity>,
+    ) -> Option<StorageType> {
+        match target {
+            None => self.components.get(component_id),
+            Some(target) => self
+                .relations
+                .get(component_id)
+                .and_then(|set| set.get(&target)),
+        }
+        .map(|info| info.storage_type)
     }
 
     #[inline]
     pub fn get_archetype_component_id(
         &self,
         component_id: ComponentId,
+        // FIXME(Relationships) treat archetype componnet id the same as component id maybe?? see other fixme
+        // then we oculd get rid of this `target` arg and same with fn above
+        target: Option<Entity>,
     ) -> Option<ArchetypeComponentId> {
-        self.components
-            .get(component_id)
-            .map(|info| info.archetype_component_id)
+        match target {
+            None => self.components.get(component_id),
+            Some(target) => self
+                .relations
+                .get(component_id)
+                .and_then(|set| set.get(&target)),
+        }
+        .map(|info| info.archetype_component_id)
     }
 }
 
@@ -329,8 +440,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, [(ComponentId, Option<Entity>)]>,
+    sparse_set_components: Cow<'static, [(ComponentId, Option<Entity>)]>,
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
@@ -453,6 +564,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 +590,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<(ComponentId, Option<Entity>)>,
+        sparse_set_components: Vec<(ComponentId, Option<Entity>)>,
     ) -> ArchetypeId {
         let table_components = Cow::from(table_components);
         let sparse_set_components = Cow::from(sparse_set_components);