Struct specs::world::EntitiesRes

pub struct EntitiesRes { /* 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 the Entities type def.

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.

Methods

impl EntitiesRes

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.

Important traits for CreateIterAtomic<'a>

impl<'a> Iterator for CreateIterAtomic<'a> type Item = Entity;

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) -> EntityResBuilder

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 delete(&self, e: Entity) -> Result<(), WrongGeneration>

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

pub fn entity(&self, id: Index) -> Entity

Returns an entity with a given id. There's no guarantee for validity, meaning the entity could be not alive.

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

Returns true if the specified entity is alive.

Trait Implementations

impl Debug for EntitiesRes

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

Formats the value using the given formatter.

impl Default for EntitiesRes

fn default() -> EntitiesRes

Returns the "default value" for a type.

impl<'a> Join for &'a EntitiesRes

type Mask = BitSetOr<&'a BitSet, &'a AtomicBitSet>

Type of joined bit mask.

type Type = Entity

Type of joined components.

type Value = Self

Type of joined storages.

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

Open this join by returning the mask and the storages.

unsafe fn get(v: &mut &'a EntitiesRes, idx: Index) -> Entity

Get a joined component value by a given index.

Important traits for JoinIter<J>

impl<J: Join> Iterator for JoinIter<J> type Item = J::Type;

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

Create a joined iterator over the contents.

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.

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 EntitiesRes

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

Create a joined parallel iterator over the contents.