Struct EntitiesViewMut

pub struct EntitiesViewMut<'a> { /* private fields */ }

Exclusive view over Entities storage.

Methods from Deref<Target = Entities>

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

Returns true if entity matches a living entity.

pub fn add_component<C, S: AddComponent<C>>( &self, entity: EntityId, storages: S, component: C, )

Adds component to entity, multiple components can be added at the same time using a tuple.
Entities is only borrowed immutably.

Panics

• entity is not alive.

Example

use shipyard::{Component, EntitiesView, ViewMut, World};

#[derive(Component)]
struct U32(u32);

let mut world = World::new();

let entity = world.add_entity(());

let (entities, mut u32s) = world.borrow::<(EntitiesView, ViewMut<U32>)>().unwrap();

entities.add_component(entity, &mut u32s, U32(0));

pub fn add_distinct_component<S: AddDistinctComponent>( &self, entity: EntityId, storages: S, component: S::Component, ) -> bool

Adds component to entity, multiple components can be added at the same time using a tuple.
If the entity already has this component, it won’t be replaced. Very useful if you want accurate modification tracking.
Entities is only borrowed immutably.

Returns true if the component was added.

Panics

• entity is not alive.

Example

use shipyard::{Component, EntitiesView, ViewMut, World};

#[derive(Component, PartialEq)]
struct U32(u32);

let mut world = World::new();

let entity = world.add_entity(());

let (entities, mut u32s) = world.borrow::<(EntitiesView, ViewMut<U32>)>().unwrap();

assert!(entities.add_distinct_component(entity, &mut u32s, U32(0)));
assert!(!entities.add_distinct_component(entity, &mut u32s, U32(0)));

pub fn delete_unchecked(&mut self, entity_id: EntityId) -> bool

Deletes an entity, returns true if the entity was alive.
If the entity has components, they will not be deleted and still be accessible using this id.

pub fn add_entity<T: AddEntity>( &mut self, storages: T, component: T::Component, ) -> EntityId

Stores component in a new entity and returns its EntityId.
Multiple components can be added at the same time using a tuple.

Example:

use shipyard::{Component, EntitiesViewMut, ViewMut, World};

#[derive(Component, Debug, PartialEq, Eq)]
struct U32(u32);

#[derive(Component, Debug, PartialEq, Eq)]
struct USIZE(usize);

let world = World::new();

let (mut entities, mut usizes, mut u32s) = world
    .borrow::<(EntitiesViewMut, ViewMut<USIZE>, ViewMut<U32>)>()
    .unwrap();

let entity = entities.add_entity((&mut usizes, &mut u32s), (USIZE(0), U32(1)));
assert_eq!(usizes[entity], USIZE(0));
assert_eq!(u32s[entity], U32(1));

pub fn bulk_add_entity<T: AddEntity + BulkReserve, I: IntoIterator<Item = T::Component>>( &mut self, storages: T, component: I, ) -> BulkEntityIter<'_>

Creates multiple new entities and returns an iterator yielding the new EntityIds.
Multiple components can be added at the same time using a tuple.

Example

use shipyard::{Component, EntitiesViewMut, ViewMut, World};

#[derive(Component)]
struct U32(u32);

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

let world = World::new();

let (mut entities, mut usizes, mut u32s) = world
    .borrow::<(EntitiesViewMut, ViewMut<USIZE>, ViewMut<U32>)>()
    .unwrap();

let new_entities =
    entities.bulk_add_entity((&mut u32s, &mut usizes), (10..20).map(|i| (U32(i as u32), USIZE(i))));

pub fn iter(&self) -> EntitiesIter<'_>

Creates an iterator over all entities.

pub fn spawn(&mut self, entity: EntityId) -> bool

Make the given entity alive.
Does nothing if an entity with a greater generation is already at this index.
Returns true if the entity is successfully spawned.

pub fn on_deletion(&mut self, f: impl FnMut(EntityId) + Send + Sync + 'static)

Sets the on entity deletion callback.

pub fn take_on_deletion( &mut self, ) -> Option<Box<dyn FnMut(EntityId) + Send + Sync + 'static>>

Remove the on entity deletion callback.

Trait Implementations

impl Borrow for EntitiesViewMut<'_>

type View<'a> = EntitiesViewMut<'a>

fn borrow<'a>( all_storages: &'a AllStorages, all_borrow: Option<SharedBorrow<'a>>, _last_run: Option<TrackingTimestamp>, _current: TrackingTimestamp, ) -> Result<Self::View<'a>, GetStorage>

This function is where the actual borrowing happens.

impl<'a> BorrowInfo for EntitiesViewMut<'a>

fn borrow_info(info: &mut Vec<TypeInfo>)

This information is used during workload creation to determine which systems can run in parallel.

fn enable_tracking(_: &mut Vec<fn(&AllStorages) -> Result<(), GetStorage>>)

Enable tracking on the World where this storage is borrowed.

impl Deref for EntitiesViewMut<'_>

type Target = Entities

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for EntitiesViewMut<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.