[Merged by Bors] - Reliable change detection

crates/bevy_core/src/time/fixed_timestep.rs

@@ -196,4 +196,8 @@ impl System for FixedTimestep {
             );
         }
     }
+
+    fn check_change_tick(&mut self, change_tick: u32) {
+        self.internal_system.check_change_tick(change_tick);
+    }
 }

crates/bevy_ecs/macros/src/lib.rs

@@ -270,11 +270,12 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
                 #[inline]
                 unsafe fn get_param(
                     state: &'a mut Self,
-                    _system_state: &'a SystemState,
+                    system_state: &'a SystemState,
                     world: &'a World,
+                    change_tick: u32,
                 ) -> Self::Item {
                     let (#(#query,)*) = &state.0;
-                    QuerySet((#(Query::new(world, #query),)*))
+                    QuerySet((#(Query::new(world, #query, system_state.last_change_tick, change_tick),)*))
                 }
             }
 
@@ -402,9 +403,10 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                 state: &'a mut Self,
                 system_state: &'a #path::system::SystemState,
                 world: &'a #path::world::World,
+                change_tick: u32,
             ) -> Self::Item {
                 #struct_name {
-                    #(#fields: <<#field_types as SystemParam>::Fetch as #path::system::SystemParamFetch>::get_param(&mut state.state.#field_indices, system_state, world),)*
+                    #(#fields: <<#field_types as SystemParam>::Fetch as #path::system::SystemParamFetch>::get_param(&mut state.state.#field_indices, system_state, world, change_tick),)*
                     #(#ignored_fields: <#ignored_field_types>::default(),)*
                 }
             }

crates/bevy_ecs/src/archetype.rs

@@ -1,6 +1,6 @@
 use crate::{
     bundle::BundleId,
-    component::{ComponentFlags, ComponentId, StorageType},
+    component::{ComponentId, StorageType},
     entity::{Entity, EntityLocation},
     storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
 };
@@ -36,9 +36,14 @@ impl ArchetypeId {
     }
 }
 
+pub enum ComponentStatus {
+    Added,
+    Mutated,
+}
+
 pub struct FromBundle {
     pub archetype_id: ArchetypeId,
-    pub bundle_flags: Vec<ComponentFlags>,
+    pub bundle_status: Vec<ComponentStatus>,
 }
 
 #[derive(Default)]
@@ -70,13 +75,13 @@ impl Edges {
         &mut self,
         bundle_id: BundleId,
         archetype_id: ArchetypeId,
-        bundle_flags: Vec<ComponentFlags>,
+        bundle_status: Vec<ComponentStatus>,
     ) {
         self.from_bundle.insert(
             bundle_id,
             FromBundle {
                 archetype_id,
-                bundle_flags,
+                bundle_status,
             },
         );
     }

crates/bevy_ecs/src/bundle.rs

@@ -1,7 +1,8 @@
 pub use bevy_ecs_macros::Bundle;
 
 use crate::{
-    component::{Component, ComponentFlags, ComponentId, Components, StorageType, TypeInfo},
+    archetype::ComponentStatus,
+    component::{Component, ComponentId, ComponentTicks, Components, StorageType, TypeInfo},
     entity::Entity,
     storage::{SparseSetIndex, SparseSets, Table},
 };
@@ -123,32 +124,56 @@ pub struct BundleInfo {
 impl BundleInfo {
     /// # Safety
     /// table row must exist, entity must be valid
+    #[allow(clippy::clippy::too_many_arguments)]
     #[inline]
     pub(crate) unsafe fn write_components<T: Bundle>(
         &self,
         sparse_sets: &mut SparseSets,
         entity: Entity,
         table: &Table,
         table_row: usize,
-        bundle_flags: &[ComponentFlags],
+        bundle_status: &[ComponentStatus],
         bundle: T,
+        change_tick: u32,
     ) {
         // NOTE: get_components calls this closure on each component in "bundle order".
         // bundle_info.component_ids are also in "bundle order"
         let mut bundle_component = 0;
         bundle.get_components(|component_ptr| {
             // SAFE: component_id was initialized by get_dynamic_bundle_info
             let component_id = *self.component_ids.get_unchecked(bundle_component);
-            let flags = *bundle_flags.get_unchecked(bundle_component);
+            let component_status = bundle_status.get_unchecked(bundle_component);
             match self.storage_types[bundle_component] {
                 StorageType::Table => {
                     let column = table.get_column(component_id).unwrap();
                     column.set_unchecked(table_row, component_ptr);
-                    column.get_flags_unchecked_mut(table_row).insert(flags);
+                    let column_status = column.get_ticks_unchecked_mut(table_row);
+                    match component_status {
+                        ComponentStatus::Added => {
+                            *column_status = ComponentTicks::new(change_tick);
+                        }
+                        ComponentStatus::Mutated => {
+                            column_status.set_changed(change_tick);
+                        }
+                    }
                 }
                 StorageType::SparseSet => {
                     let sparse_set = sparse_sets.get_mut(component_id).unwrap();
-                    sparse_set.insert(entity, component_ptr, flags);
+                    match component_status {
+                        ComponentStatus::Added => {
+                            sparse_set.insert(
+                                entity,
+                                component_ptr,
+                                ComponentTicks::new(change_tick),
+                            );
+                        }
+                        ComponentStatus::Mutated => {
+                            sparse_set
+                                .get_ticks(entity)
+                                .unwrap()
+                                .set_changed(change_tick);
+                        }
+                    }
                 }
             }
             bundle_component += 1;

crates/bevy_ecs/src/component/mod.rs

@@ -3,7 +3,6 @@ mod type_info;
 pub use type_info::*;
 
 use crate::storage::SparseSetIndex;
-use bitflags::bitflags;
 use std::{
     alloc::Layout,
     any::{Any, TypeId},
@@ -303,9 +302,55 @@ impl Components {
     }
 }
 
-bitflags! {
-    pub struct ComponentFlags: u8 {
-        const ADDED = 1;
-        const MUTATED = 2;
+#[derive(Copy, Clone, Debug)]
+pub struct ComponentTicks {
+    pub(crate) added: u32,
+    pub(crate) changed: u32,
+}
+
+impl ComponentTicks {
+    #[inline]
+    pub fn is_added(&self, last_change_tick: u32, change_tick: u32) -> bool {
+        // The comparison is relative to `change_tick` so that we can detect changes over the whole
+        // `u32` range. Comparing directly the ticks would limit to half that due to overflow
+        // handling.
+        let component_delta = change_tick.wrapping_sub(self.added);
+        let system_delta = change_tick.wrapping_sub(last_change_tick);
+
+        component_delta < system_delta
+    }
+
+    #[inline]
+    pub fn is_changed(&self, last_change_tick: u32, change_tick: u32) -> bool {
+        let component_delta = change_tick.wrapping_sub(self.changed);
+        let system_delta = change_tick.wrapping_sub(last_change_tick);
+
+        component_delta < system_delta
+    }
+
+    pub(crate) fn new(change_tick: u32) -> Self {
+        Self {
+            added: change_tick,
+            changed: change_tick,
+        }
+    }
+
+    pub(crate) fn check_ticks(&mut self, change_tick: u32) {
+        check_tick(&mut self.added, change_tick);
+        check_tick(&mut self.changed, change_tick);
+    }
+
+    #[inline]
+    pub(crate) fn set_changed(&mut self, change_tick: u32) {
+        self.changed = change_tick;
+    }
+}
+
+fn check_tick(last_change_tick: &mut u32, change_tick: u32) {
+    let tick_delta = change_tick.wrapping_sub(*last_change_tick);
+    const MAX_DELTA: u32 = (u32::MAX / 4) * 3;
+    // Clamp to max delta
+    if tick_delta > MAX_DELTA {
+        *last_change_tick = change_tick.wrapping_sub(MAX_DELTA);
     }
 }