Struct rinecs::entity::Entities

pub struct Entities<'a> { /* fields omitted */ }

Allows to access and modify the Send components of the entities in the world.

Implementations

impl<'a> Entities<'a>

pub fn iter_for<'e, S: UnorderedDataSend<'e> + ReadOnlyOp<'e>>(
    &'e self
) -> <S as UnorderedData<'e>>::Iter

Iterator over all the components that match the operator

Can only be used with read only operators

for pos in entities.iter_for::<Read<Position>>(){

}

Will iterate over all the entities that have both position and velocity and update the position by adding the velocity to it. In this example position can be modified cause we use the Write operator but velocity can only be read.

pub fn iter_for_mut<'e, S: UnorderedDataSend<'e>>(
    &'e mut self
) -> <S as UnorderedData<'e>>::IterMut

Iterator over all the components that match the operator

Can be used with operators that access a storage mutably

for (pos, vel) in entities.iter_for_mut::<(Write<Position>, Read<Velocity>)>(){
    pos.x += vel.x;
    pos.y += vel.y;
}

Will iterate over all the entities that have both position and velocity and update the position by adding the velocity to it. In this example position can be modified cause we use the Write operator but velocity can only be read.

pub unsafe fn unsafe_iter_for_mut<'e, S: UnorderedDataSend<'e>>(
    &'e mut self
) -> <S as UnorderedData<'e>>::Iter

pub fn storage_for<'r, S>(&'r self) -> Sto<'r, S> where
    S: UnorderedDataSend<'r> + ReadOnlyOp<'r>, 

Storage for the operator passed as type parameter

Calling iter_for can be slow if it needs to be called lots of times. In those cases calling instead storage_for once and then iter() on it multiple times can make performance much better

let mut storage = entities.storage_for_mut::<(Write<Position>, Read<Velocity>)>().unwrap();
for i in 0..1000000 {
    for (pos, vel) in storage.iter_mut() {
        pos.x += vel.x;
        pos.y += vel.y;
    }
}

pub fn storage_for_mut<'r, S>(&'r mut self) -> Sto<'r, S> where
    S: UnorderedDataSend<'r>, 

pub fn ordered_iter_for<'e, S: OrderedDataSend<'e> + ReadOnlyOrderedOp<'e>>(
    &'e self
) -> <S as OrderedData<'e>>::Iter

Iterator over ordered data

Similar to iter_for but to be used with operators that specify an order like ReadAndParent in which parents will be processed first and then their children

pub fn ordered_iter_for_mut<'e, S: OrderedDataSend<'e>>(
    &'e mut self
) -> <S as OrderedData<'e>>::Iter

Iterator over ordered data

Similar to iter_for but to be used with operators that specify an order like ReadAndParent in which parents will be processed first and then their children

pub fn ordered_storage_for<'e, S: OrderedDataSend<'e> + ReadOnlyOrderedOp<'e>>(
    &'e self
) -> Option<<S as OrderedData<'e>>::Storage>

Storage for the operator passed as type parameter

Calling ordered_iter_for can be slow if it needs to be called lots of times. In those cases calling instead ordered_storage_for once and then iter() on it multiple times can make performance much better

pub fn ordered_storage_for_mut<'e, S: OrderedDataSend<'e>>(
    &'e mut self
) -> Option<<S as OrderedData<'e>>::Storage>

pub fn iter_for_entities<'e, U, E>(&'e self, entities: E) -> E::IntoEntitiesIter where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>,
    U::Storage: ReadOnlyStorage, 

Iterator for the specified operators over a set of entities instead of every entity in the world

It’s usage is similar to iter_for but instead of iterating over all the entities it only returns components that match the operators for the entities passed as parameter

let e1 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let e2 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let e3 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let entities = world.entities();
for pos in entities.iter_for_entities::<Read<Position>, _>(&vec![e1, e2]){
    //...
}

The operators parameter in this method needs a second type for the entities iterator type which can jsut be elided with a _ since it’ll be guessed from the passed parameter

pub fn iter_for_entities_mut<'e, U, E>(
    &'e mut self,
    entities: E
) -> E::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>, 

pub fn iter_for_entities_opt<'e, U, E>(
    &'e self,
    entities: E
) -> E::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>,
    U::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<'e, U, E>(
    &'e mut self,
    entities: E
) -> E::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>, 

pub unsafe fn unsafe_iter_for_entities_mut<'e, U, E>(
    &'e mut self,
    entities: E
) -> EntitiesComponentIter<'_, <E as IntoIterator>::IntoIter, <U as UnorderedData<'e>>::Storage> where
    U: UnorderedDataSend<'e>,
    E: IntoIterator<Item = Entity>,
    <U as UnorderedData<'e>>::Storage: StorageRef<'e>, 

pub fn changed_iter_for<'r, S>(
    &'r self
) -> EntitiesComponentIter<'r, S::ChangedIter, <S as UnorderedData<'r>>::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + ReadOnlyOp<'r> + 'r,
    <S as UnorderedData<'r>>::Storage: StorageRef<'r>, 

Iterator for the specified operators only over the entities whose component as specified in the first operator has changed

The first component specified has to implement the Changes trait and have a Changed or AutoChanged storage

Changed and Autochanged storages keep an index of which elements have changed. This method uses that index and will only ever iterate over elements that have changed. So it can greatly accelerate some operations when we only need to access elements that changed during the current run.

To get a correct result this method should only be used after running changes_iter_with for Changed storages or update_changed for AutoChanged storages.

With an AutoChanged storage, the component needs to implement the Changes trait which informs rinecs if the component did change and allows to reset it’s changed state at the end of the run:

#[derive(Component, Debug)]
#[autochanges]
struct Position{x: i32, y: i32, changed: bool}

impl Position {
    pub fn new(x: i32, y: i32) -> Position {
        Position{ x, y, changed: false}
    }

    pub fn set(&mut self, x: i32, y: i32) {
        self.changed = self.x != x || self.y != y;
        self.x = x;
        self.y = y;
    }
}

impl Changes for Position{
    fn has_changed(&self) -> bool{
        self.changed
    }

    fn reset_changed(&mut self){
        self.changed = false;
    }
}

let e1 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let e2 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let e3 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let mut entities = world.entities();
let mut v = 0;
let unique_entities = UniqueEntities::try_new(vec![e1, e2]).unwrap();
for pos in entities.iter_for_entities_mut::<Write<Position>, _>(&unique_entities) {
    pos.set(v, v);
    v += 1;
}

entities.update_changed::<Position>();

// will only iterate over e1 and e2 since e1 was set to the same value and e3 was never touched
let mut iter = entities.changed_iter_for::<(Read<Position>, Entity)>();
assert_eq!(Some(e2), iter.next().map(|(_,e)| e));
assert_eq!(None, iter.next().map(|(_,e)| e));

With a Changed storage, the component doesn’t need any trait but we need to manually inform rinecs if the component did change by only updating it using the changes_iter_with method before being able to use update_changed. This method is faster and should be use when we can ensure that the changed state of a component will only change on this system:

#[derive(Component, Debug)]
#[changes]
struct Position{x: i32, y: i32}

impl Position {
    pub fn new(x: i32, y: i32) -> Position {
        Position{ x, y }
    }

    pub fn update(&mut self, x: i32, y: i32) -> bool {
        let changed = self.x != x || self.y != y;
        self.x = x;
        self.y = y;
        changed
    }
}

let e1 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let e2 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let e3 = world.new_entity()
    .add(Position::new(0, 0))
    .build();
let mut entities = world.entities();
let mut v = 0;
entities.changes_iter_with::<(Write<Position>, Entity), _>(|(pos, e)| {
    if e != e3 {
        let changed = pos.update(v, v);
        v += 1;
        changed
    }else{
        false
    }
});

// will only iterate over e2 since e1 was set to the same value and e3 was never touched
let mut iter = entities.changed_iter_for::<(Read<Position>, Entity)>();
assert_eq!(Some(e2), iter.next().map(|(_,e)| e));
assert_eq!(None, iter.next().map(|(_,e)| e));

pub fn changed_iter_for_mut<'r, S>(
    &'r mut self
) -> EntitiesComponentIter<'r, S::ChangedIter, <S as UnorderedData<'r>>::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + 'r,
    <S as UnorderedData<'r>>::Storage: StorageRef<'r>, 

pub fn has_storage_changed<C: ComponentSend>(&self) -> bool where
    <C as Component>::Storage: Storage<'s, C>,
    <C as Component>::Storage: ChangedStorageExt<'a>, 

Returns true if a Changed or AutoChanged storage changed during the last run

This will return true if any compoennt was modified (returns true on has_changed) but also if any was inserted or removed from the storage.

To get a correct result this method should only be used after running changes_iter_with for Changed storages or update_changed for AutoChanged storages.

pub fn changes_iter_with<'r, S, F>(&'r mut self, changed: F) where
    S: ChangesDataSend<'r>,
    <S as UnorderedData<'r>>::Storage: StorageRef<'r>,
    F: FnMut(<S as UnorderedData<'r>>::ComponentsRef) -> bool, 

Update Changed storages

This method has to be called once per run to update Changed storages. It receives a function that usually updates the components and returns a boolean indicating if the component changed (true) or not (false).

This is usually faster than AutoChanged storages where the update of the components can happen anywhere but it’s less flexible cause only changes done in this call will be taken into account as changed

pub fn changes_ordered_iter_with<'r, S, F>(&'r mut self, changed: F) where
    S: ChangesOrderedDataSend<'r>,
    F: FnMut(<S as OrderedData<'r>>::ComponentsRef) -> bool, 

Update Changed storages using an ordered iterator

This method has to be called once per run to update Changed storages. It receives a function that usually updates the components and returns a boolean indicating if the component changed (true) or not (false).

This is usually faster than AutoChanged storages where the update of the components can happen anywhere but it’s less flexible cause only changes done in this call will be taken into account as changed

pub fn update_changed<C: ComponentSend>(&self) where
    <C as Component>::Storage: AutoChangedStorageExt<'a>, 

Update AutoChanged storages

This method has to be called once per run to update AutoChanged storages. It should be run after all the systems that modify the component and before using changed_iter_for on it.

pub fn entity_components<'r, S>(
    &'r self,
    entity: &Entity
) -> Option<<S as UnorderedData<'r>>::ComponentsRef> where
    S: UnorderedDataSend<'r> + ReadOnlyOp<'r> + 'r,
    S::Storage: StorageRef<'r, Component = S::ComponentsRef>, 

Similar to iter_for_entities but for one entity instead of several

let e1 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .add(Velocity{x: 0., y: 0.})
    .build();
let entities = world.entities();
let (pos, vel) = entities
    .entity_components::<(Read<Position>, Read<Velocity>)>(&e1)
    .unwrap();

pub fn entity_components_mut<'r, S>(
    &'r mut self,
    entity: &Entity
) -> Option<<S as UnorderedData<'r>>::ComponentsRef> where
    S: UnorderedDataSend<'r> + 'r,
    S::Storage: StorageRef<'r, Component = S::ComponentsRef>, 

pub fn component_for<'r, C: ComponentSend>(
    &'r self,
    entity: &Entity
) -> Option<Ptr<'r, C>> where
    <C as Component>::Storage: Storage<'s, C>, 

Returns a component for reading for the passed entity

let e1 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let entities = world.entities();
let pos = entities.component_for::<Position>(&e1).unwrap();

pub fn component_for_mut<'r, C: ComponentSend>(
    &'r self,
    entity: &Entity
) -> Option<PtrMut<'r, C>> where
    <C as Component>::Storage: Storage<'s, C>, 

Returns a component for writing for the passed entity

let e1 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let entities = world.entities();
let mut pos = entities.component_for_mut::<Position>(&e1).unwrap();

pub fn has_component<C: 'static>(&self, entity: &Entity) -> bool

Returns true if the entity has the specified component

let e1 = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .build();
let entities = world.entities();
assert!(entities.has_component::<Position>(&e1));

pub fn tree_node_for<'r, C: ComponentSend>(
    &'r self,
    entity: &Entity
) -> Option<NodePtr<'r, C>> where
    <C as Component>::Storage: HierarchicalStorage<'b, C>, 

Returns the node for a hierarchical component

pub fn tree_node_for_mut<'r, C: ComponentSend>(
    &'r self,
    entity: &Entity
) -> Option<NodePtrMut<'r, C>> where
    <C as Component>::Storage: HierarchicalStorage<'b, C>, 

Returns the node for a hierarchical component for writing

pub fn clone(&mut self) -> Entities<'_>

pub fn as_storages(&mut self) -> EntityStorages<'_>

pub fn split<D: DataAccesses>(&mut self) -> (Entities<'_>, Entities<'_>)

Trait Implementations

impl<'a> EntitiesExt<'a> for Entities<'a>

fn iter_for<'e, S: UnorderedDataSend<'e> + ReadOnlyOp<'e>>(
    &'e self
) -> <S as UnorderedData<'e>>::Iter

Iterator over all the components that match the operator

fn iter_for_mut<'e, S: UnorderedDataSend<'e>>(
    &'e mut self
) -> <S as UnorderedData<'e>>::IterMut

Iterator over all the components that match the operator

fn ordered_iter_for<'e, S: OrderedDataSend<'e> + ReadOnlyOrderedOp<'e>>(
    &'e self
) -> <S as OrderedData<'e>>::Iter

Iterator over ordered data

fn ordered_iter_for_mut<'e, S: OrderedDataSend<'e>>(
    &'e mut self
) -> <S as OrderedData<'e>>::Iter

Iterator over ordered data

fn iter_for_entities<'e, U, E>(&'e self, entities: E) -> E::IntoEntitiesIter where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>,
    U::Storage: ReadOnlyStorage, 

Iterator for the specified operators over a set of entities instead of every entity in the world

fn iter_for_entities_mut<'e, U, E>(
    &'e mut self,
    entities: E
) -> E::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>, 

fn iter_for_entities_opt<'e, U, E>(
    &'e self,
    entities: E
) -> E::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>,
    U::Storage: ReadOnlyStorage, 

fn iter_for_entities_opt_mut<'e, U, E>(
    &'e mut self,
    entities: E
) -> E::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'e, U::Storage>,
    U: UnorderedDataSend<'e>, 

fn entity_components<'r, S>(
    &'r self,
    entity: &Entity
) -> Option<<S as UnorderedData<'r>>::ComponentsRef> where
    S: UnorderedDataSend<'r> + ReadOnlyOp<'r> + 'r,
    S::Storage: StorageRef<'r, Component = S::ComponentsRef>, 

Similar to iter_for_entities but for one entity instead of several

fn entity_components_mut<'r, S>(
    &'r mut self,
    entity: &Entity
) -> Option<<S as UnorderedData<'r>>::ComponentsRef> where
    S: UnorderedDataSend<'r> + 'r,
    S::Storage: StorageRef<'r, Component = S::ComponentsRef>, 

fn component_for<C: ComponentSend>(&self, entity: &Entity) -> Option<Ptr<'_, C>> where
    <C as Component>::Storage: Storage<'s, C>, 

Returns a component for reading for the passed entity

fn component_for_mut<C: ComponentSend>(
    &self,
    entity: &Entity
) -> Option<PtrMut<'_, C>> where
    <C as Component>::Storage: Storage<'s, C>, 

Returns a component for writing for the passed entity

fn has_component<C: 'static>(&self, entity: &Entity) -> bool

Returns true if the entity has the specified component

fn tree_node_for<C: ComponentSend>(
    &self,
    entity: &Entity
) -> Option<NodePtr<'_, C>> where
    <C as Component>::Storage: HierarchicalStorage<'b, C>, 

Returns the node for a hierarchical component

fn tree_node_for_mut<C: ComponentSend>(
    &self,
    entity: &Entity
) -> Option<NodePtrMut<'_, C>> where
    <C as Component>::Storage: HierarchicalStorage<'b, C>, 

Returns the node for a hierarchical component for writing

fn changed_iter_for<'r, S>(
    &'r self
) -> EntitiesComponentIter<'r, S::ChangedIter, <S as UnorderedData<'r>>::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + ReadOnlyOp<'r> + 'r,
    <S as UnorderedData<'r>>::Storage: StorageRef<'r>, 

Iterator for the specified operators only over the entities whose component as specified in the first operator has changed

fn changed_iter_for_mut<'r, S>(
    &'r mut self
) -> EntitiesComponentIter<'r, S::ChangedIter, <S as UnorderedData<'r>>::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + 'r,
    <S as UnorderedData<'r>>::Storage: StorageRef<'r>, 

fn storage_for<'r, S>(&'r self) -> Sto<'r, S> where
    S: UnorderedDataSend<'r> + ReadOnlyOp<'r>, 

Storage for the operator passed as type parameter

fn storage_for_mut<'r, S>(&'r mut self) -> Sto<'r, S> where
    S: UnorderedDataSend<'r>, 

impl<'a> EntitiesStorage for Entities<'a>

fn storage<C: Component>(
    &self
) -> Option<ReadGuardRef<'_, <C as Component>::Storage>>

fn storage_mut<C: Component>(
    &self
) -> Option<WriteGuardRef<'_, <C as Component>::Storage, <C as Component>::MutStorageCacheGuard>>

fn entities_ref(&self) -> &[(Entity, MaskType)]

fn component_mask<C: 'static>(&self) -> MaskType

fn entities_for_mask<S: FastIndexExt>(
    &self,
    query_mask: Bitmask,
    storage: &S
) -> IndexGuard<'_>

fn lazy_entities_for_mask(&self, query_mask: Bitmask) -> LazyIndexGuard<'_>

fn ordered_entities_for<C: Component, S: FastIndexExt>(
    &self,
    query_mask: Bitmask,
    unordered_storage: &S
) -> OrderedIndexGuard<'_> where
    <C as Component>::Storage: HierarchicalStorage<'b, C>, 

impl<'a> Send for Entities<'a>

impl<'a> Sync for Entities<'a>