Struct oxygengine_core::ecs::EntityBuilder

pub struct EntityBuilder { /* fields omitted */ }

Helper for incrementally constructing a bundle of components with dynamic component types

Prefer reusing the same builder over creating new ones repeatedly.

let mut world = World::new();
let mut builder = EntityBuilder::new();
builder.add(123).add("abc");
let e = world.spawn(builder.build()); // builder can now be reused
assert_eq!(*world.get::<i32>(e).unwrap(), 123);
assert_eq!(*world.get::<&str>(e).unwrap(), "abc");

Implementations

impl EntityBuilder

pub fn new() -> EntityBuilder

Create a builder representing an entity with no components

pub fn add<T>(&mut self, component: T) -> &mut EntityBuilder where
    T: Component, 

Add component to the entity.

If the bundle already contains a component of type T, it will be dropped and replaced with the most recently added one.

pub fn add_bundle(&mut self, bundle: impl DynamicBundle) -> &mut EntityBuilder

Add all components in bundle to the entity.

If the bundle contains any component which matches the type of a component already in the EntityBuilder, the newly added component from the bundle will replace the old component and the old component will be dropped.

pub fn build(&mut self) -> BuiltEntity<'_>

Construct a Bundle suitable for spawning

pub fn has<T>(&self) -> bool where
    T: Component, 

Checks to see if the component of type T exists

pub fn get<T>(&self) -> Option<&T> where
    T: Component, 

Borrow the component of type T, if it exists

pub fn get_mut<T>(&mut self) -> Option<&mut T> where
    T: Component, 

Uniquely borrow the component of type T, if it exists

pub fn component_types(&self) -> impl Iterator<Item = TypeId>

Enumerate the types of the entity builder’s components

pub fn clear(&mut self)

Drop previously added components

The builder is cleared implicitly when an entity is built, so this doesn’t usually need to be called.

Trait Implementations

impl Default for EntityBuilder

pub fn default() -> EntityBuilder

Returns the “default value” for a type.