Merge branch 'archetype_event' into query_entities

Author: re0312

crates/bevy_asset/src/io/wasm.rs

@@ -81,7 +81,10 @@ impl HttpWasmAssetReader {
                 let reader = VecReader::new(bytes);
                 Ok(reader)
             }
-            404 => Err(AssetReaderError::NotFound(path)),
+            // Some web servers, including itch.io's CDN, return 403 when a requested file isn't present.
+            // TODO: remove handling of 403 as not found when it's easier to configure
+            // see https://github.com/bevyengine/bevy/pull/19268#pullrequestreview-2882410105
+            403 | 404 => Err(AssetReaderError::NotFound(path)),
             status => Err(AssetReaderError::HttpError(status)),
         }
     }

crates/bevy_ecs/src/archetype.rs

@@ -36,8 +36,7 @@ use core::{
 use nonmax::NonMaxU32;
 
 #[derive(Event)]
-#[allow(dead_code)]
-
+#[expect(dead_code, reason = "Prepare for the upcoming Query as Entities")]
 pub(crate) struct ArchetypeCreated(pub ArchetypeId);
 
 /// An opaque location within a [`Archetype`].

crates/bevy_ecs/src/bundle.rs

@@ -1035,7 +1035,7 @@ impl<'w> BundleInserter<'w> {
         change_tick: Tick,
     ) -> Self {
         // SAFETY: We will not make any accesses to the command queue, component or resource data of this world
-        let mut bundle_info = world.bundles.get_unchecked(bundle_id);
+        let bundle_info = world.bundles.get_unchecked(bundle_id);
         let bundle_id = bundle_info.id();
         let (new_archetype_id, is_new_created) = bundle_info.insert_bundle_into_archetype(
             &mut world.archetypes,
@@ -1045,12 +1045,7 @@ impl<'w> BundleInserter<'w> {
             archetype_id,
         );
 
-        if is_new_created {
-            world.trigger(ArchetypeCreated(new_archetype_id));
-            bundle_info = world.bundles.get_unchecked(bundle_id);
-        }
-
-        if new_archetype_id == archetype_id {
+        let inserter = if new_archetype_id == archetype_id {
             let archetype = &mut world.archetypes[archetype_id];
             // SAFETY: The edge is assured to be initialized when we called insert_bundle_into_archetype
             let archetype_after_insert = unsafe {
@@ -1110,7 +1105,15 @@ impl<'w> BundleInserter<'w> {
                     world: world.as_unsafe_world_cell(),
                 }
             }
+        };
+
+        if is_new_created {
+            inserter
+                .world
+                .into_deferred()
+                .trigger(ArchetypeCreated(new_archetype_id));
         }
+        inserter
     }
 
     /// # Safety
@@ -1200,16 +1203,16 @@ impl<'w> BundleInserter<'w> {
                         unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
                     entities.set(
                         swapped_entity.index(),
-                        EntityLocation {
+                        Some(EntityLocation {
                             archetype_id: swapped_location.archetype_id,
                             archetype_row: location.archetype_row,
                             table_id: swapped_location.table_id,
                             table_row: swapped_location.table_row,
-                        },
+                        }),
                     );
                 }
                 let new_location = new_archetype.allocate(entity, result.table_row);
-                entities.set(entity.index(), new_location);
+                entities.set(entity.index(), Some(new_location));
                 let after_effect = bundle_info.write_components(
                     table,
                     sparse_sets,
@@ -1249,19 +1252,19 @@ impl<'w> BundleInserter<'w> {
                         unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
                     entities.set(
                         swapped_entity.index(),
-                        EntityLocation {
+                        Some(EntityLocation {
                             archetype_id: swapped_location.archetype_id,
                             archetype_row: location.archetype_row,
                             table_id: swapped_location.table_id,
                             table_row: swapped_location.table_row,
-                        },
+                        }),
                     );
                 }
                 // PERF: store "non bundle" components in edge, then just move those to avoid
                 // redundant copies
                 let move_result = table.move_to_superset_unchecked(result.table_row, new_table);
                 let new_location = new_archetype.allocate(entity, move_result.new_row);
-                entities.set(entity.index(), new_location);
+                entities.set(entity.index(), Some(new_location));
 
                 // If an entity was moved into this entity's table spot, update its table row.
                 if let Some(swapped_entity) = move_result.swapped_entity {
@@ -1271,12 +1274,12 @@ impl<'w> BundleInserter<'w> {
 
                     entities.set(
                         swapped_entity.index(),
-                        EntityLocation {
+                        Some(EntityLocation {
                             archetype_id: swapped_location.archetype_id,
                             archetype_row: swapped_location.archetype_row,
                             table_id: swapped_location.table_id,
                             table_row: result.table_row,
-                        },
+                        }),
                     );
 
                     if archetype.id() == swapped_location.archetype_id {
@@ -1426,7 +1429,7 @@ impl<'w> BundleRemover<'w> {
         bundle_id: BundleId,
         require_all: bool,
     ) -> Option<Self> {
-        let mut bundle_info = world.bundles.get_unchecked(bundle_id);
+        let bundle_info = world.bundles.get_unchecked(bundle_id);
         // SAFETY: Caller ensures archetype and bundle ids are correct.
         let (new_archetype_id, is_new_created) = unsafe {
             bundle_info.remove_bundle_from_archetype(
@@ -1444,11 +1447,6 @@ impl<'w> BundleRemover<'w> {
             return None;
         }
 
-        if is_new_created {
-            world.trigger(ArchetypeCreated(new_archetype_id));
-            bundle_info = world.bundles.get_unchecked(bundle_id);
-        }
-
         let (old_archetype, new_archetype) =
             world.archetypes.get_2_mut(archetype_id, new_archetype_id);
 
@@ -1462,13 +1460,20 @@ impl<'w> BundleRemover<'w> {
             Some((old.into(), new.into()))
         };
 
-        Some(Self {
+        let remover = Self {
             bundle_info: bundle_info.into(),
             new_archetype: new_archetype.into(),
             old_archetype: old_archetype.into(),
             old_and_new_table: tables,
             world: world.as_unsafe_world_cell(),
-        })
+        };
+        if is_new_created {
+            remover
+                .world
+                .into_deferred()
+                .trigger(ArchetypeCreated(new_archetype_id));
+        }
+        Some(remover)
     }
 
     /// This can be passed to [`remove`](Self::remove) as the `pre_remove` function if you don't want to do anything before removing.
@@ -1588,12 +1593,12 @@ impl<'w> BundleRemover<'w> {
 
             world.entities.set(
                 swapped_entity.index(),
-                EntityLocation {
+                Some(EntityLocation {
                     archetype_id: swapped_location.archetype_id,
                     archetype_row: location.archetype_row,
                     table_id: swapped_location.table_id,
                     table_row: swapped_location.table_row,
-                },
+                }),
             );
         }
 
@@ -1629,12 +1634,12 @@ impl<'w> BundleRemover<'w> {
 
                 world.entities.set(
                     swapped_entity.index(),
-                    EntityLocation {
+                    Some(EntityLocation {
                         archetype_id: swapped_location.archetype_id,
                         archetype_row: swapped_location.archetype_row,
                         table_id: swapped_location.table_id,
                         table_row: location.table_row,
-                    },
+                    }),
                 );
                 world.archetypes[swapped_location.archetype_id]
                     .set_entity_table_row(swapped_location.archetype_row, location.table_row);
@@ -1650,7 +1655,7 @@ impl<'w> BundleRemover<'w> {
 
         // SAFETY: The entity is valid and has been moved to the new location already.
         unsafe {
-            world.entities.set(entity.index(), new_location);
+            world.entities.set(entity.index(), Some(new_location));
         }
 
         (new_location, pre_remove_result)
@@ -1689,7 +1694,7 @@ impl<'w> BundleSpawner<'w> {
         bundle_id: BundleId,
         change_tick: Tick,
     ) -> Self {
-        let mut bundle_info = world.bundles.get_unchecked(bundle_id);
+        let bundle_info = world.bundles.get_unchecked(bundle_id);
         let (new_archetype_id, is_new_created) = bundle_info.insert_bundle_into_archetype(
             &mut world.archetypes,
             &mut world.storages,
@@ -1698,20 +1703,22 @@ impl<'w> BundleSpawner<'w> {
             ArchetypeId::EMPTY,
         );
 
-        if is_new_created {
-            world.trigger(ArchetypeCreated(new_archetype_id));
-            bundle_info = world.bundles.get_unchecked(bundle_id);
-        }
-
         let archetype = &mut world.archetypes[new_archetype_id];
         let table = &mut world.storages.tables[archetype.table_id()];
-        Self {
+        let spawner = Self {
             bundle_info: bundle_info.into(),
             table: table.into(),
             archetype: archetype.into(),
             change_tick,
             world: world.as_unsafe_world_cell(),
+        };
+        if is_new_created {
+            spawner
+                .world
+                .into_deferred()
+                .trigger(ArchetypeCreated(new_archetype_id));
         }
+        spawner
     }
 
     #[inline]
@@ -1757,7 +1764,7 @@ impl<'w> BundleSpawner<'w> {
                 InsertMode::Replace,
                 caller,
             );
-            entities.set(entity.index(), location);
+            entities.set(entity.index(), Some(location));
             entities.mark_spawn_despawn(entity.index(), caller, self.change_tick);
             (location, after_effect)
         };

crates/bevy_ecs/src/entity/clone_entities.rs

@@ -5,6 +5,7 @@ use bumpalo::Bump;
 use core::any::TypeId;
 
 use crate::{
+    archetype::Archetype,
     bundle::Bundle,
     component::{Component, ComponentCloneBehavior, ComponentCloneFn, ComponentId, ComponentInfo},
     entity::{hash_map::EntityHashMap, Entities, Entity, EntityMapper},
@@ -340,6 +341,7 @@ impl<'a, 'b> ComponentCloneCtx<'a, 'b> {
 pub struct EntityCloner {
     filter_allows_components: bool,
     filter: HashSet<ComponentId>,
+    filter_required: HashSet<ComponentId>,
     clone_behavior_overrides: HashMap<ComponentId, ComponentCloneBehavior>,
     move_components: bool,
     linked_cloning: bool,
@@ -356,6 +358,7 @@ impl Default for EntityCloner {
             linked_cloning: false,
             default_clone_fn: ComponentCloneBehavior::global_default_fn(),
             filter: Default::default(),
+            filter_required: Default::default(),
             clone_behavior_overrides: Default::default(),
             clone_queue: Default::default(),
             deferred_commands: Default::default(),
@@ -459,6 +462,12 @@ impl EntityCloner {
         {
             let world = world.as_unsafe_world_cell();
             let source_entity = world.get_entity(source).expect("Source entity must exist");
+            let target_archetype = (!self.filter_required.is_empty()).then(|| {
+                world
+                    .get_entity(target)
+                    .expect("Target entity must exist")
+                    .archetype()
+            });
 
             #[cfg(feature = "bevy_reflect")]
             // SAFETY: we have unique access to `world`, nothing else accesses the registry at this moment, and we clone
@@ -475,7 +484,7 @@ impl EntityCloner {
             bundle_scratch = BundleScratch::with_capacity(archetype.component_count());
 
             for component in archetype.components() {
-                if !self.is_cloning_allowed(&component) {
+                if !self.is_cloning_allowed(&component, target_archetype) {
                     continue;
                 }
 
@@ -599,9 +608,19 @@ impl EntityCloner {
         target
     }
 
-    fn is_cloning_allowed(&self, component: &ComponentId) -> bool {
-        (self.filter_allows_components && self.filter.contains(component))
-            || (!self.filter_allows_components && !self.filter.contains(component))
+    fn is_cloning_allowed(
+        &self,
+        component: &ComponentId,
+        target_archetype: Option<&Archetype>,
+    ) -> bool {
+        if self.filter_allows_components {
+            self.filter.contains(component)
+                || target_archetype.is_some_and(|archetype| {
+                    !archetype.contains(*component) && self.filter_required.contains(component)
+                })
+        } else {
+            !self.filter.contains(component) && !self.filter_required.contains(component)
+        }
     }
 }
 
@@ -803,9 +822,9 @@ impl<'w> EntityClonerBuilder<'w> {
             if let Some(info) = self.world.components().get_info(id) {
                 for required_id in info.required_components().iter_ids() {
                     if self.entity_cloner.filter_allows_components {
-                        self.entity_cloner.filter.insert(required_id);
+                        self.entity_cloner.filter_required.insert(required_id);
                     } else {
-                        self.entity_cloner.filter.remove(&required_id);
+                        self.entity_cloner.filter_required.remove(&required_id);
                     }
                 }
             }
@@ -823,9 +842,9 @@ impl<'w> EntityClonerBuilder<'w> {
             if let Some(info) = self.world.components().get_info(id) {
                 for required_id in info.required_components().iter_ids() {
                     if self.entity_cloner.filter_allows_components {
-                        self.entity_cloner.filter.remove(&required_id);
+                        self.entity_cloner.filter_required.remove(&required_id);
                     } else {
-                        self.entity_cloner.filter.insert(required_id);
+                        self.entity_cloner.filter_required.insert(required_id);
                     }
                 }
             }
@@ -1400,4 +1419,36 @@ mod tests {
         );
         assert!(world.resource::<FromWorldCalled>().0);
     }
+
+    #[test]
+    fn cloning_with_required_components_preserves_existing() {
+        #[derive(Component, Clone, PartialEq, Debug, Default)]
+        #[require(B(5))]
+        struct A;
+
+        #[derive(Component, Clone, PartialEq, Debug)]
+        struct B(u32);
+
+        let mut world = World::default();
+
+        let e = world.spawn((A, B(0))).id();
+        let e_clone = world.spawn(B(1)).id();
+
+        EntityCloner::build(&mut world)
+            .deny_all()
+            .allow::<A>()
+            .clone_entity(e, e_clone);
+
+        assert_eq!(world.entity(e_clone).get::<A>(), Some(&A));
+        assert_eq!(world.entity(e_clone).get::<B>(), Some(&B(1)));
+
+        let e_clone2 = world.spawn(B(2)).id();
+
+        EntityCloner::build(&mut world)
+            .allow_all()
+            .deny::<A>()
+            .clone_entity(e, e_clone2);
+
+        assert_eq!(world.entity(e_clone2).get::<B>(), Some(&B(2)));
+    }
 }