Add simple Disabled marker

crates/bevy_ecs/src/entity_disabling.rs

@@ -26,7 +26,13 @@ use crate::{
     component::{ComponentId, Components, StorageType},
     query::FilteredAccess,
 };
-use bevy_ecs_macros::Resource;
+use bevy_ecs_macros::{Component, Resource};
+
+/// A marker component for disabled entities. See [the module docs] for more info.
+///
+/// [the module docs]: crate::entity_disabling
+#[derive(Component)]
+pub struct Disabled;
 
 /// The default filters for all queries, these are used to globally exclude entities from queries.
 /// See the [module docs](crate::entity_disabling) for more info.
@@ -37,10 +43,6 @@ pub struct DefaultQueryFilters {
 }
 
 impl DefaultQueryFilters {
-    #[cfg_attr(
-        not(test),
-        expect(dead_code, reason = "No Disabled component exist yet")
-    )]
     /// Set the [`ComponentId`] for the entity disabling marker
     pub(crate) fn set_disabled(&mut self, component_id: ComponentId) -> Option<()> {
         if self.disabled.is_some() {

crates/bevy_ecs/src/lib.rs

@@ -134,6 +134,7 @@ mod tests {
         change_detection::Ref,
         component::{require, Component, ComponentId, RequiredComponents, RequiredComponentsError},
         entity::Entity,
+        entity_disabling::DefaultQueryFilters,
         prelude::Or,
         query::{Added, Changed, FilteredAccess, QueryFilter, With, Without},
         resource::Resource,
@@ -1530,6 +1531,7 @@ mod tests {
     #[test]
     fn filtered_query_access() {
         let mut world = World::new();
+        world.remove_resource::<DefaultQueryFilters>();
         let query = world.query_filtered::<&mut A, Changed<B>>();
 
         let mut expected = FilteredAccess::<ComponentId>::default();

crates/bevy_ecs/src/system/commands/mod.rs

@@ -2516,15 +2516,15 @@ mod tests {
 
         fn nothing() {}
 
-        assert!(world.iter_resources().count() == 0);
+        let resources = world.iter_resources().count();
         let id = world.register_system_cached(nothing);
-        assert!(world.iter_resources().count() == 1);
+        assert_eq!(world.iter_resources().count(), resources + 1);
         assert!(world.get_entity(id.entity).is_ok());
 
         let mut commands = Commands::new(&mut queue, &world);
         commands.unregister_system_cached(nothing);
         queue.apply(&mut world);
-        assert!(world.iter_resources().count() == 0);
+        assert_eq!(world.iter_resources().count(), resources);
         assert!(world.get_entity(id.entity).is_err());
     }
 

crates/bevy_ecs/src/world/mod.rs

@@ -40,6 +40,7 @@ use crate::{
         RequiredComponentsError, Tick,
     },
     entity::{AllocAtWithoutReplacement, Entities, Entity, EntityLocation},
+    entity_disabling::{DefaultQueryFilters, Disabled},
     event::{Event, EventId, Events, SendBatchIds},
     observer::Observers,
     query::{DebugCheckedUnwrap, QueryData, QueryFilter, QueryState},
@@ -159,6 +160,11 @@ impl World {
 
         let on_despawn = OnDespawn::register_component_id(self);
         assert_eq!(ON_DESPAWN, on_despawn);
+
+        let disabled = self.register_component::<Disabled>();
+        let mut filters = DefaultQueryFilters::default();
+        filters.set_disabled(disabled);
+        self.insert_resource(filters);
     }
     /// Creates a new empty [`World`].
     ///
@@ -3217,6 +3223,15 @@ impl World {
 }
 
 impl World {
+    /// Returns true if the type id is used internally, components and resources used internally
+    /// most likely should not be affected by things like saving and loading
+    pub fn is_internal_type(type_id: TypeId) -> bool {
+        if type_id == TypeId::of::<DefaultQueryFilters>() {
+            return true;
+        }
+        false
+    }
+
     /// Gets a pointer to the resource with the id [`ComponentId`] if it exists.
     /// The returned pointer must not be used to modify the resource, and must not be
     /// dereferenced after the immutable borrow of the [`World`] ends.
@@ -3268,6 +3283,7 @@ impl World {
     /// # struct B(u32);
     /// #
     /// # let mut world = World::new();
+    /// # world.remove_resource::<bevy_ecs::entity_disabling::DefaultQueryFilters>();
     /// # world.insert_resource(A(1));
     /// # world.insert_resource(B(2));
     /// let mut total = 0;
@@ -3766,6 +3782,7 @@ mod tests {
         change_detection::DetectChangesMut,
         component::{ComponentDescriptor, ComponentInfo, StorageType},
         entity::hash_set::EntityHashSet,
+        entity_disabling::{DefaultQueryFilters, Disabled},
         ptr::OwningPtr,
         resource::Resource,
         world::error::EntityFetchError,
@@ -3955,6 +3972,7 @@ mod tests {
     #[test]
     fn iter_resources() {
         let mut world = World::new();
+        world.remove_resource::<DefaultQueryFilters>();
         world.insert_resource(TestResource(42));
         world.insert_resource(TestResource2("Hello, world!".to_string()));
         world.insert_resource(TestResource3);
@@ -3981,6 +3999,7 @@ mod tests {
     #[test]
     fn iter_resources_mut() {
         let mut world = World::new();
+        world.remove_resource::<DefaultQueryFilters>();
         world.insert_resource(TestResource(42));
         world.insert_resource(TestResource2("Hello, world!".to_string()));
         world.insert_resource(TestResource3);
@@ -4447,4 +4466,15 @@ mod tests {
             None
         );
     }
+
+    #[test]
+    fn new_world_has_disabling() {
+        let mut world = World::new();
+        world.spawn(Foo);
+        world.spawn((Foo, Disabled));
+        assert_eq!(1, world.query::<&Foo>().iter(&world).count());
+
+        world.remove_resource::<DefaultQueryFilters>();
+        assert_eq!(2, world.query::<&Foo>().iter(&world).count());
+    }
 }

crates/bevy_scene/src/scene.rs

@@ -1,6 +1,7 @@
 use crate::{DynamicScene, SceneSpawnError};
 use bevy_asset::Asset;
 use bevy_ecs::{
+    component::ComponentInfo,
     entity::{hash_map::EntityHashMap, Entity, SceneEntityMapper},
     reflect::{AppTypeRegistry, ReflectComponent, ReflectMapEntities, ReflectResource},
     world::World,
@@ -61,6 +62,15 @@ impl Scene {
 
         // Resources archetype
         for (component_id, resource_data) in self.world.storages().resources.iter() {
+            if world
+                .components()
+                .get_info(component_id)
+                .and_then(ComponentInfo::type_id)
+                .filter(|&type_id| World::is_internal_type(type_id))
+                .is_some()
+            {
+                continue;
+            }
             if !resource_data.is_present() {
                 continue;
             }

crates/bevy_scene/src/scene_filter.rs

@@ -1,3 +1,4 @@
+use bevy_ecs::world::World;
 use bevy_utils::{hashbrown::hash_set::IntoIter, HashSet};
 use core::any::{Any, TypeId};
 
@@ -154,6 +155,9 @@ impl SceneFilter {
     ///
     /// [`Unset`]: SceneFilter::Unset
     pub fn is_allowed_by_id(&self, type_id: TypeId) -> bool {
+        if World::is_internal_type(type_id) {
+            return false;
+        }
         match self {
             Self::Unset => true,
             Self::Allowlist(list) => list.contains(&type_id),