Bundle refactor - Option bundles and Box<dyn Bundle>

benches/benches/bevy_ecs/bundles/insert_many.rs

@@ -0,0 +1,68 @@
+use benches::bench;
+use bevy_ecs::{component::Component, world::World};
+use criterion::Criterion;
+
+const ENTITY_COUNT: usize = 2_000;
+
+#[derive(Component)]
+struct C<const N: usize>(usize);
+
+#[derive(Component)]
+struct W<T>(T);
+
+pub fn insert_many(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group(bench!("insert_many"));
+
+    group.bench_function("all", |bencher| {
+        bencher.iter(|| {
+            let mut world = World::new();
+            for _ in 0..ENTITY_COUNT {
+                world
+                    .spawn_empty()
+                    .insert(C::<0>(1))
+                    .insert(C::<1>(1))
+                    .insert(C::<2>(1))
+                    .insert(C::<3>(1))
+                    .insert(C::<4>(1))
+                    .insert(C::<5>(1))
+                    .insert(C::<6>(1))
+                    .insert(C::<7>(1))
+                    .insert(C::<8>(1))
+                    .insert(C::<9>(1))
+                    .insert(C::<10>(1))
+                    .insert(C::<11>(1))
+                    .insert(C::<12>(1))
+                    .insert(C::<13>(1))
+                    .insert(C::<14>(1));
+            }
+        });
+    });
+
+    group.bench_function("only_last", |bencher| {
+        bencher.iter(|| {
+            let mut world = World::new();
+            for _ in 0..ENTITY_COUNT {
+                world
+                    .spawn((
+                        C::<0>(1),
+                        C::<1>(1),
+                        C::<2>(1),
+                        C::<3>(1),
+                        C::<4>(1),
+                        C::<5>(1),
+                        C::<6>(1),
+                        C::<7>(1),
+                        C::<8>(1),
+                        C::<9>(1),
+                        C::<10>(1),
+                        C::<11>(1),
+                        C::<12>(1),
+                        C::<13>(1),
+                    ))
+                    .insert(C::<14>(1));
+            }
+        });
+    });
+
+    group.finish();
+}

benches/benches/bevy_ecs/bundles/mod.rs

@@ -0,0 +1,63 @@
+use bevy_ecs::{
+    bundle::{BoundedBundleKey, Bundle, ComponentsFromBundle},
+    component::{ComponentId, ComponentsRegistrator, RequiredComponents, StorageType},
+    ptr::OwningPtr,
+};
+use criterion::criterion_group;
+
+mod insert_many;
+mod spawn_many;
+mod spawn_many_zst;
+mod spawn_one_zst;
+
+criterion_group!(
+    benches,
+    spawn_one_zst::spawn_one_zst,
+    spawn_many_zst::spawn_many_zst,
+    spawn_many::spawn_many,
+    insert_many::insert_many,
+);
+
+struct MakeDynamic<B>(B);
+
+// SAFETY:
+// - setting is_static and is_bounded to false is always safe and makes cache_key irrelevant
+// - everything else is delegated to B, which is a valid Bundle
+unsafe impl<B: Bundle> Bundle for MakeDynamic<B> {
+    fn is_static() -> bool {
+        false
+    }
+
+    fn is_bounded() -> bool {
+        false
+    }
+
+    fn cache_key(&self) -> BoundedBundleKey {
+        BoundedBundleKey::empty()
+    }
+
+    fn component_ids(
+        &self,
+        components: &mut ComponentsRegistrator,
+        ids: &mut impl FnMut(ComponentId),
+    ) {
+        self.0.component_ids(components, ids);
+    }
+
+    fn register_required_components(
+        &self,
+        components: &mut ComponentsRegistrator,
+        required_components: &mut RequiredComponents,
+    ) {
+        self.0
+            .register_required_components(components, required_components);
+    }
+}
+
+impl<B: ComponentsFromBundle> ComponentsFromBundle for MakeDynamic<B> {
+    type Effect = <B as ComponentsFromBundle>::Effect;
+
+    fn get_components(self, func: &mut impl FnMut(StorageType, OwningPtr<'_>)) -> Self::Effect {
+        self.0.get_components(func)
+    }
+}