Struct async_ecs::entity::entities::Entities

pub struct Entities { /* fields omitted */ }

The entities of this ECS. This is a resource, stored in the World. If you just want to access it in your system, you can also use Read<Entities>.

Please note that you should never get this mutably in a system, because it would block all the other systems.

You need to call World::maintain after creating / deleting entities with this struct.

Implementations

impl Entities

pub fn allocate(&mut self) -> Entity

Creates a new entity. This will be persistent after this call.

pub fn create(&self) -> Entity

Creates a new entity atomically. This will be persistent as soon as you call World::maintain.

If you want a lazy entity builder, take a look at LazyUpdate::create_entity.

In case you have access to the World, you can also use World::create_entity which creates the entity and the components immediately.

pub fn create_iter(&self) -> CreateIterAtomic<'_>

Returns an iterator which creates new entities atomically. They will be persistent as soon as you call World::maintain.

pub fn build_entity(&self) -> AtomicBuilder<'_>

Similar to the create method above this creates an entity atomically, and then returns a builder which can be used to insert components into various storages if available.

pub fn kill(&mut self, delete: &[Entity]) -> Result<(), Error>

Kills a list of entities immediately.

pub fn delete(&self, entity: Entity) -> Result<(), Error>

Deletes an entity atomically. The associated components will be deleted as soon as you call World::maintain.

pub fn is_alive(&self, entity: Entity) -> bool

Returns true if the specified entity is alive.

pub fn maintain(&mut self) -> Vec<Entity>

Maintains the allocated entities, mainly dealing with atomically allocated or killed entities.

Trait Implementations

impl Default for Entities

pub fn default() -> Entities

Returns the "default value" for a type.

impl<'a> Join for &'a Entities

type Mask = &'a BitSet

Type of joined bit mask.

type Type = Entity

Type of joined components.

type Value = Self

Type of joined storages.

pub unsafe fn open(self) -> (Self::Mask, Self)

Open this join by returning the mask and the storages.

pub unsafe fn get(v: &mut &'a Entities, index: Index) -> Entity

Get a joined component value by a given index.

pub fn join(self) -> JoinIter<Self> where
    Self: Sized, 

Create a joined iterator over the contents.

pub fn maybe(self) -> MaybeJoin<Self> where
    Self: Sized, 

Returns a Join-able structure that yields all indices, returning None for all missing elements and Some(T) for found elements.

pub fn is_unconstrained() -> bool

If this Join typically returns all indices in the mask, then iterating over only it or combined with other joins that are also dangerous will cause the JoinIter/ParJoin to go through all indices which is usually not what is wanted and will kill performance.

impl<'a> ParJoin for &'a Entities

pub fn par_join(self) -> JoinParIter<Self> where
    Self: Sized,