Struct ChildBundles

pub struct ChildBundles<B: Bundle, I: IntoIterator<Item = B>>(pub I);

A component that, when added to an entity, will add a child entity with the given bundle.

This component will be removed from the entity immediately upon being spawned, and the supplied iterator will be iterated to completion to generate the data needed for each child. See ChildBundle for a more convenient API when adding only one child (or multiple children with distinct bundle types).

Under the hood, this is done using component lifecycle hooks.

Examples

Just like when using Commands::spawn_batch, any iterator that returns a bundle of the same type can be used.

Working with vectors, arrays and other collections is straightforward:

use bevy_ecs::prelude::*;
use i_cant_believe_its_not_bsn::ChildBundles;

#[derive(Component)]
struct Name(&'static str);

fn spawn_hierarchy_with_vector(mut commands: Commands) {
  commands.spawn(
   (Name("Zeus"),
    ChildBundles([Name("Athena"), Name("Apollo"), Name("Hermes")])
  ));
}

However, generator-style iterators can also be used to dynamically vary the number and property of children:

use bevy_ecs::prelude::*;
use i_cant_believe_its_not_bsn::ChildBundles;

#[derive(Component)]
struct A;

#[derive(Component)]
struct ChildNumber(usize);

fn spawn_hierarchy_with_generator(mut commands: Commands) {
  commands.spawn(
   (A, // Component on parent
     ChildBundles((0..3).map(|i| (ChildNumber(i)))) // Each child will have a ChildNumber component
   ));
}

Tuple Fields

0: I

Trait Implementations

impl<B: Clone + Bundle, I: Clone + IntoIterator<Item = B>> Clone for ChildBundles<B, I>

fn clone(&self) -> ChildBundles<B, I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Bundle, I: IntoIterator<Item = B> + Send + Sync + 'static> Component for ChildBundles<B, I>

const STORAGE_TYPE: StorageType = StorageType::SparseSet

This is a sparse set component as it’s only ever added and removed, never iterated over.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn register_required_components( _component_id: ComponentId, _components: &mut ComponentsRegistrator<'_>, _required_components: &mut RequiredComponents, _inheritance_depth: u16, _recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl<B: Debug + Bundle, I: Debug + IntoIterator<Item = B>> Debug for ChildBundles<B, I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Default + Bundle, I: Default + IntoIterator<Item = B>> Default for ChildBundles<B, I>

fn default() -> ChildBundles<B, I>

Returns the “default value” for a type.