Struct aery::scope::WorldScope

pub struct WorldScope<'a, E> { /* private fields */ }

Builder API to construct hierarchies of relations.

use bevy::prelude::*;
use aery::prelude::*;

#[derive(Relation)]
struct ChildOf;

#[derive(Component)]
struct C<const N: usize>;

fn sys(world: &mut World) {
    world.spawn(C::<0>)
         .scope::<ChildOf>(|scope| {
             // 1, 2, 3 are implicitly `ChildOf` the last spawned entity (0)
             scope.add(C::<1>)
                  .add(C::<2>)
                  .add(C::<3>)
                  .scope::<ChildOf>(|scope| {
                       // 4, 5 are implicitly `ChildOf` the last spawned entity (3)
                      scope.add(C::<4>)
                           .add(C::<5>);
                  });
         });
}

Implementations

impl<T: Relation> WorldScope<'_, T>

pub fn scope<R: Relation>( &mut self, func: impl FnMut(&mut WorldScope<'_, R>) ) -> &mut Self

Scope the last spawned entity via R. Any targets or hosts that are added in the scope implicitly use R as the edge.

impl<R: Relation> WorldScope<'_, R>

pub fn add(&mut self, bundle: impl Bundle) -> &mut Self

Spawn an entity from a bundle and have it target the currently scoped entity via R.

pub fn add_target(&mut self, bundle: impl Bundle) -> &mut Self

Spawn an entity from a bundle and set it as a target of the currently scoped entity.

pub fn add_and( &mut self, func: impl for<'e> FnMut(&mut EntityWorldMut<'e>) ) -> &mut Self

Spawn an entity and have it target the currently scoped entity via. This function takes a closure to provide entity mut access.

pub fn add_target_and( &mut self, func: impl for<'e> FnMut(&mut EntityWorldMut<'e>) ) -> &mut Self

Spawn an entity and set it as a target of the currently scoped entity. This function takes a closure to provide entity mut access.