Struct World 

pub struct World {
    pub new_archetype_capacity: usize,
    /* private fields */
}

Fields

new_archetype_capacity: usize

Implementations

impl World

pub fn with_new_archetype_capacity(self, value: usize) -> Self

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn entities(&self) -> impl Iterator<Item = Entity> + '_

pub fn archetypes(&self) -> impl Iterator<Item = &Archetype>

pub fn archetypes_mut(&mut self) -> impl Iterator<Item = &mut Archetype>

pub fn added(&self) -> &WorldChanges

pub fn removed(&self) -> &WorldChanges

pub fn updated(&self) -> Option<RwLockReadGuard<'_, WorldChanges>>

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

pub fn component_did_changed<T>(&self) -> bool

pub fn component_did_changed_raw(&self, type_hash: TypeHash) -> bool

pub fn entity_component_did_changed<T>(&self, entity: Entity) -> bool

pub fn entity_component_did_changed_raw( &self, entity: Entity, type_hash: TypeHash, ) -> bool

pub fn update<T>(&self, entity: Entity)

pub fn update_raw(&self, entity: Entity, type_hash: TypeHash)

pub fn clear_changes(&mut self)

pub fn clear(&mut self)

pub fn spawn(&mut self, bundle: impl Bundle) -> Result<Entity, WorldError>

pub unsafe fn spawn_uninitialized<T: BundleColumns>( &mut self, ) -> Result<(Entity, ArchetypeEntityRowAccess<'_>), WorldError>

Safety

pub unsafe fn spawn_uninitialized_raw( &mut self, columns: Vec<ArchetypeColumnInfo>, ) -> Result<(Entity, ArchetypeEntityRowAccess<'_>), WorldError>

Safety

pub fn despawn(&mut self, entity: Entity) -> Result<(), WorldError>

pub unsafe fn despawn_uninitialized( &mut self, entity: Entity, ) -> Result<(), WorldError>

Safety

pub fn insert( &mut self, entity: Entity, bundle: impl Bundle, ) -> Result<(), WorldError>

pub fn remove<T: BundleColumns>( &mut self, entity: Entity, ) -> Result<(), WorldError>

pub fn remove_raw( &mut self, entity: Entity, columns: Vec<ArchetypeColumnInfo>, ) -> Result<(), WorldError>

pub fn merge<const LOCKING: bool>( &mut self, other: Self, processor: &WorldProcessor, ) -> Result<(), WorldError>

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

pub fn has_entity_component<T: Component>(&self, entity: Entity) -> bool

pub fn has_entity_component_raw( &self, entity: Entity, component: TypeHash, ) -> bool

pub fn find_by<const LOCKING: bool, T: Component + PartialEq>( &self, data: &T, ) -> Option<Entity>

pub fn component<const LOCKING: bool, T: Component>( &self, entity: Entity, ) -> Result<ComponentRef<'_, LOCKING, T>, WorldError>

pub fn component_mut<const LOCKING: bool, T: Component>( &self, entity: Entity, ) -> Result<ComponentRefMut<'_, LOCKING, T>, WorldError>

pub fn get<const LOCKING: bool, T: Component>( &self, entity: Entity, unique: bool, ) -> Result<ArchetypeEntityColumnAccess<'_, LOCKING, T>, WorldError>

pub fn dynamic_get<const LOCKING: bool>( &self, type_hash: TypeHash, entity: Entity, unique: bool, ) -> Result<ArchetypeDynamicEntityColumnAccess<'_, LOCKING>, WorldError>

pub fn row<const LOCKING: bool>( &self, entity: Entity, ) -> Result<ArchetypeEntityRowAccess<'_>, WorldError>

pub fn query<'a, const LOCKING: bool, Fetch: TypedQueryFetch<'a, LOCKING>>( &'a self, ) -> TypedQueryIter<'a, LOCKING, Fetch>

pub fn dynamic_query<'a, const LOCKING: bool>( &'a self, filter: &DynamicQueryFilter, ) -> DynamicQueryIter<'a, LOCKING>

pub fn lookup<'a, const LOCKING: bool, Fetch: TypedLookupFetch<'a, LOCKING>>( &'a self, entities: impl IntoIterator<Item = Entity> + 'a, ) -> TypedLookupIter<'a, LOCKING, Fetch>

pub fn lookup_access<'a, const LOCKING: bool, Fetch: TypedLookupFetch<'a, LOCKING>>( &'a self, ) -> TypedLookupAccess<'a, LOCKING, Fetch>

pub fn dynamic_lookup<'a, const LOCKING: bool>( &'a self, filter: &DynamicQueryFilter, entities: impl IntoIterator<Item = Entity> + 'a, ) -> DynamicLookupIter<'a, LOCKING>

pub fn dynamic_lookup_access<'a, const LOCKING: bool>( &'a self, filter: &DynamicQueryFilter, ) -> DynamicLookupAccess<'a, LOCKING>

pub fn relate<const LOCKING: bool, T: Component>( &mut self, payload: T, from: Entity, to: Entity, ) -> Result<(), WorldError>

pub fn unrelate<const LOCKING: bool, T: Component>( &mut self, from: Entity, to: Entity, ) -> Result<(), WorldError>

pub fn unrelate_any<const LOCKING: bool, T: Component>( &mut self, entity: Entity, ) -> Result<(), WorldError>

pub fn has_relation<const LOCKING: bool, T: Component>( &self, from: Entity, to: Entity, ) -> bool

pub fn relations<const LOCKING: bool, T: Component>( &self, ) -> impl Iterator<Item = (Entity, &T, Entity)> + '_

pub fn relations_mut<const LOCKING: bool, T: Component>( &self, ) -> impl Iterator<Item = (Entity, &mut T, Entity)> + '_

pub fn relations_outgoing<const LOCKING: bool, T: Component>( &self, from: Entity, ) -> impl Iterator<Item = (Entity, &T, Entity)> + '_

pub fn relations_outgoing_mut<const LOCKING: bool, T: Component>( &self, from: Entity, ) -> impl Iterator<Item = (Entity, &mut T, Entity)> + '_

pub fn relations_incomming<const LOCKING: bool, T: Component>( &self, to: Entity, ) -> impl Iterator<Item = (Entity, &T, Entity)> + '_

pub fn relations_incomming_mut<const LOCKING: bool, T: Component>( &self, to: Entity, ) -> impl Iterator<Item = (Entity, &mut T, Entity)> + '_

pub fn traverse_outgoing<const LOCKING: bool, T: Component>( &self, entities: impl IntoIterator<Item = Entity>, ) -> RelationsTraverseIter<'_, LOCKING, T>

pub fn traverse_incoming<const LOCKING: bool, T: Component>( &self, entities: impl IntoIterator<Item = Entity>, ) -> RelationsTraverseIter<'_, LOCKING, T>

Trait Implementations

impl Default for World

fn default() -> Self

Returns the “default value” for a type.

impl<'a> UniverseFetch<'a> for &'a World

type Value = &'a World

fn fetch( universe: &'a Universe, _: Entity, ) -> Result<Self::Value, Box<dyn Error>>