Struct rin::ecs::World

pub struct World { /* fields omitted */ }

Main rinecs object that contains all entities, resources and systems.

A world is the first object one creates when using rinecs.

Through it one can create every other element, like entities and their components.

Also resources, globbally accessible data, is stored in the world and passed later to the systems.

The systems order of exectuion is defined by adding systems to the world and using barriers to define groups of parallel execution.

Once the world is setup one can call run_once or the more specific run_multi_threaded and run_single_threaded to run the systems in the order they were added.

Implementations

impl World

pub fn new() -> World

pub fn register_with_capacity<'r, C>(&mut self, capacity: usize) where
    C: ComponentSend,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Registers a type that implements Send as Component reserving an initial amount of memory.

Send components can be used from System which run from different threads.

Calling this method is not needed but will make initial insertion faster if we can estimate the total amount of components beforehand

pub fn register_thread_local_with_capacity<'r, C>(&mut self, capacity: usize) where
    C: ComponentSend,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Registers a type that can only be used from the main thread asComponent reserving an initial amount of memory.

Send components can be used from System which run from different threads.

Calling this method is not needed but will make initial insertion faster if we can estimate the total amount of components beforehand

pub fn new_entity(&mut self) -> EntityBuilder<'_>

Returns an EntityBuilder that allows to create an entity and it’s components.

let e = world.new_entity()
    .add(Position{x: 0., y: 0.})
    .add(Velocity{x: 0., y: 0.})
    .build();

pub fn component_mask<C>(&self) -> U256 where
    C: 'static, 

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

Returns an Entities object that allows to iterate over all the Send components of entities in this world.

pub fn entities_thread_local(&mut self) -> EntitiesThreadLocal<'_>

Returns an EntitiesThreadLocal object that allows to iterate over all the Send and non Send components of entities in this world.

pub fn entities_creation(&mut self) -> EntitiesCreation<'_>

Returns an EntitiesCreation object that allows to iterate over all the Send and non Send components of entities in this world and create new entities and resources.

pub fn debug_entities(&mut self) -> EntitiesDebug<'_>

Returns an EntitiesDebug object that allows to iterate over all the Send and non Send components of entities in this world and debug / serialize them

pub fn add_component_to<'r, C>(&mut self, entity: &Entity, component: C) where
    C: ComponentSend,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send Component to an already existing Entity.

pub fn add_component_to_thread_local<'r, C>(
    &mut self,
    entity: &Entity,
    component: C
) where
    C: ComponentThreadLocal,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send Component to an already existing Entity.

pub fn add_tag_to<C>(&mut self, entity: &Entity) where
    C: 'static, 

pub fn add_child_component_to<'r, C>(
    &mut self,
    parent: &Entity,
    entity: &Entity,
    component: C
) where
    C: ComponentSend,
    <C as Component>::Storage: for<'b> HierarchicalStorage<'b, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send Component to an already existing Entity.

pub fn add_child_component_to_thread_local<'r, C>(
    &mut self,
    parent: &Entity,
    entity: &Entity,
    component: C
) where
    C: ComponentThreadLocal,
    <C as Component>::Storage: for<'b> HierarchicalStorage<'b, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send Component to an already existing Entity.

pub fn add_slice_component_to<'r, C, I>(
    &mut self,
    entity: &Entity,
    component: I
) where
    C: OneToNComponentSend,
    I: IntoIterator<Item = C>,
    <C as Component>::Storage: for<'s> OneToNStorage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send OneToNComponent to an already existing Entity.

This allows to add a slice of components to an entity instead of only one component. This components are stored contiguously in memory for all the entities.

pub fn add_slice_component_to_thread_local<'r, C, I>(
    &mut self,
    entity: &Entity,
    component: I
) where
    C: OneToNComponentThreadLocal,
    I: IntoIterator<Item = C>,
    <C as Component>::Storage: for<'s> OneToNStorage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send OneToNComponent to an already existing Entity.

This allows to add a slice of components to an entity instead of only one component. This components are stored contiguously in memory for all the entities.

pub fn remove_component_from<'r, C>(&mut self, entity: &Entity) where
    C: Component,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Removes a compoenent of the specified type from an entity.

pub fn remove_entity(&mut self, entity: &Entity)

Removes an Entity and all it’s compoenents.

pub fn add_resource<T>(&mut self, resource: T) where
    T: 'static + Send, 

Adds a Send resource to the world.

Resources are globally accesible by any system through the Resources object passed as parameter to them.

pub fn add_resource_as_trait<T, U, F, FMut>(&mut self, resource: (T, F, FMut)) where
    T: 'static + Send,
    F: Fn(&T) -> &U + 'static,
    U: 'static + Send + ?Sized,
    FMut: Fn(&mut T) -> &mut U + 'static, 

Adds a Send resource to the world accessible as a &dyn Trait.

Resources are globally accesible by any system through the Resources object passed as parameter to them.

pub fn resources(&self) -> Resources<'_>

Returns a Resources object that allows to access all the Send resources in the world.

pub fn entities_and_resources(&mut self) -> (Entities<'_>, Resources<'_>)

pub fn remove_resource<T>(&mut self) -> Option<T> where
    T: 'static, 

Removes a resource of the specified type.

pub fn add_resource_thread_local<T>(&mut self, resource: T) where
    T: 'static, 

Adds a non Send resource to the world.

Non Send resources are globally accesible by any SystemThreadLocal through the ResourcesThreadLocal object passed as parameter to them.

pub fn add_resource_as_trait_thread_local<T, U, F, FMut>(
    &mut self,
    resource: (T, F, FMut)
) where
    T: 'static,
    F: Fn(&T) -> &U + 'static,
    U: 'static + ?Sized,
    FMut: Fn(&mut T) -> &mut U + 'static, 

Adds a non Send resource to the world accessible as a &dyn Trait.

Non Send resources are are globally accesible by any system through the Resources object passed as parameter to them.

pub fn resource<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static, 

Returns a resource of the specified type if it exists for reading.

pub fn resource_as<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static + ?Sized, 

Returns a resource of the specified type if it exists for reading.

pub fn resource_mut<T>(&self) -> Option<WriteGuardRef<'_, T, ()>> where
    T: 'static, 

Returns a resource of the specified type if it exists for writing.

pub fn resources_thread_local(&self) -> ResourcesThreadLocal<'_>

Returns a ResourcesThreadLocal object that allows to access all the resources in the world.

pub fn entities_and_resources_thread_local(
    &mut self
) -> (EntitiesThreadLocal<'_>, ResourcesThreadLocal<'_>)

pub fn resources_creation(&mut self) -> ResourcesCreation<'_>

Returns a Resources object that allows to access all the Send and non Send resources in the world and also allows to create new resources and delete them.

pub fn entities_and_resources_creation(
    &mut self
) -> (EntitiesCreation<'_>, ResourcesCreation<'_>)

pub fn add_system<S>(&mut self, system: S) -> &mut World where
    S: System + 'static, 

Adds a Send System that will be run in the order it was added.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_once<S>(&mut self, system: S) -> &mut World where
    S: SystemOnce + 'static, 

Adds a Send System that will be run in the order it was added.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_with_data<S, D>(&mut self, system: S, data: D) -> &mut World where
    D: Send + 'static,
    S: FnMut(&mut D, Entities<'_>, Resources<'_>) + Send + 'static, 

Adds a Send System that will be run in the order it was added and data that will be passed to the system as first parameter.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_thread_local<S>(&mut self, system: S) -> &mut World where
    S: SystemThreadLocal + 'static, 

Adds a non Send System that will be run in the order it was added.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_system_once_thread_local<S>(&mut self, system: S) -> &mut World where
    S: SystemOnceThreadLocal + 'static, 

Adds a non Send System that will be run only once

SystemOnceThreadLocal will run in the main thread but can run in parallel with Send systems.

pub fn add_system_thread_local_with_data<S, D>(
    &mut self,
    system: S,
    data: D
) -> &mut World where
    D: 'static,
    S: FnMut(&mut D, EntitiesThreadLocal<'_>, ResourcesThreadLocal<'_>) + 'static, 

Adds a non Send System that will be run in the order it was added and data that will be passed to the system as first parameter.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_creation_system<S>(&mut self, system: S) -> &mut World where
    S: CreationSystem + 'static, 

Adds a CreationSystem that will be run in the order it was added.

CreationSystems run alone with no other system running in parallel.

pub fn add_creation_system_once<S>(&mut self, system: S) -> &mut World where
    S: CreationSystemOnce + 'static, 

Adds a CreationSystemOnce

CreationSystemsOnce run once and alone with no other system running in parallel.

pub fn add_creation_system_with_data<S, D>(
    &mut self,
    system: S,
    data: D
) -> &mut World where
    D: 'static,
    S: FnMut(&mut D, EntitiesCreation<'_>, ResourcesCreation<'_>) + 'static, 

Adds a CreationSystem that will be run in the order it was added and data that will be passed to the system as first parameter.

CreationSystems run alone with no other system running in parallel.

pub fn add_system_with<S>(&mut self, system: S) -> Builder<'_, '_, S> where
    S: System + 'static, 

Adds a Send System that will be run in the order it was added using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_once_with<S>(&mut self, system: S) -> BuilderOnce<'_, '_, S> where
    S: SystemOnce + 'static, 

Adds a Send SystemOnce that will be run only once using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_thread_local_with<S>(
    &mut self,
    system: S
) -> BuilderThreadLocal<'_, '_, S> where
    S: SystemThreadLocal + 'static, 

Adds a thread local System using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_system_once_thread_local_with<S>(
    &mut self,
    system: S
) -> BuilderOnceThreadLocal<'_, '_, S> where
    S: SystemOnceThreadLocal + 'static, 

Adds a thread local System that will be run only once using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_creation_system_with<S>(
    &mut self,
    system: S
) -> BuilderCreation<'_, '_, S> where
    S: CreationSystem + 'static, 

Adds a creation System using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

CreationSystems run alone with no other system running in parallel.

pub fn add_creation_system_once_with<S>(
    &mut self,
    system: S
) -> BuilderCreationOnce<'_, '_, S> where
    S: CreationSystemOnce + 'static, 

Adds a creation System that will be run only once using a Builder that allows to set some system settings like the name it’ll show up with in stats or the conditions under it will run.

The settings set using the builder will override those that system sets itself through attributes or implementation.

CreationSystems run alone with no other system running in parallel.

pub fn add_debug_system<S>(&mut self, system: S) -> &mut World where
    S: SystemDebug + 'static, 

Adds a SystemDebug

SystemDebug run alone with no other system running in parallel.

pub fn add_barrier<B>(&mut self) -> &mut World where
    B: 'static + Barrier, 

Delimits all the systems that will run in parallel.

Only systems between barriers (or creation and debug systems) will run in parallel with each other.

Barriers allow to create groups of systems that run in parallel including thread local systems that run one by one in the main thread but in parallel with Send systems.

pub fn render_systems_dependency_graph<P>(&mut self, file: P) where
    P: AsRef<Path>, 

pub fn run_once(&mut self)

Runs all the systems in the world once.

If the parallel_systems features are enabled the systems will al be run in the main thread sequentially but without monitoring for parallelism conflicts.

If parallel_systems is enabled it’ll run Send and thread local systems in parallel, running thread local systems always from the main thread. Creation and Debug systems act as a barrier and run alone.

pub fn run_multi_threaded(&mut self)

Only available when the default parallel_systems feature is enabled it’ll run Send and thread local systems in parallel, running thread local systems always from the main thread. Creation and Debug systems act as a barrier and run alone.

pub fn run_single_threaded(&mut self)

It runs all he systems in the world in the main thread sequentially

pub fn is_registered<C>(&self) -> bool where
    C: Component, 

pub fn creation_storage<C>(&mut self) -> CreationSto<'_, C> where
    C: Component, 

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

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

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

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

Trait Implementations

impl<'a> CreationContextExt<'a> for World

pub fn with_entities_and_resources_creation<'e, F, R>(&'e mut self, f: F) -> R where
    F: FnOnce(EntitiesCreation<'e>, ResourcesCreation<'e>) -> R, 

impl Default for World

pub fn default() -> World

Returns the “default value” for a type.

impl<'a> EntitiesCreationExt<'a> for World

pub fn with_entities_creation<'e, F, R>(&'e mut self, f: F) -> R where
    F: FnOnce(EntitiesCreation<'e>) -> R, 

pub fn new_entity(&mut self) -> EntityBuilder<'_>

Returns an EntityBuilder that allows to create an entity and it’s components.

pub fn creation_storage<C>(&mut self) -> CreationSto<'_, C> where
    C: Component, 

pub fn add_component_to<'r, C>(&mut self, entity: &Entity, component: C) where
    C: ComponentSend,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send Component to an already existing Entity.

pub fn add_component_to_thread_local<'r, C>(
    &mut self,
    entity: &Entity,
    component: C
) where
    C: ComponentThreadLocal,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send Component to an already existing Entity.

pub fn add_tag_to<C>(&mut self, entity: &Entity) where
    C: 'static, 

Adds a Tag to an already existing Entity.

pub fn add_child_component_to<'r, C>(
    &mut self,
    parent: &Entity,
    entity: &Entity,
    component: C
) where
    C: ComponentSend,
    <C as Component>::Storage: for<'b> HierarchicalStorage<'b, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send Component to an already existing Entity.

pub fn add_child_component_to_thread_local<'r, C>(
    &mut self,
    parent: &Entity,
    entity: &Entity,
    component: C
) where
    C: ComponentThreadLocal,
    <C as Component>::Storage: for<'b> HierarchicalStorage<'b, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send Component to an already existing Entity.

pub fn add_slice_component_to<'r, C, I>(
    &mut self,
    entity: &Entity,
    component: I
) where
    C: OneToNComponentSend,
    I: IntoIterator<Item = C>,
    <C as Component>::Storage: for<'s> OneToNStorage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a Send OneToNComponent to an already existing Entity.

pub fn add_slice_component_to_thread_local<'r, C, I>(
    &mut self,
    entity: &Entity,
    component: I
) where
    C: OneToNComponentThreadLocal,
    I: IntoIterator<Item = C>,
    <C as Component>::Storage: for<'s> OneToNStorage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Adds a non Send OneToNComponent to an already existing Entity.

pub fn remove_component_from<'r, C>(&mut self, entity: &Entity) where
    C: Component,
    <C as Component>::Storage: for<'s> Storage<'s, C>,
    <<C as Component>::Storage as Storage<'r, C>>::Get: DebugParameter, 

Removes a compoenent of the specified type from an entity.

pub fn remove_entity(&mut self, entity: &Entity)

Removes an Entity and all it’s compoenents.

impl<'a> EntitiesExt<'a> for World

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

Iterator over all the components that match the operator

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

Iterator over all the components that match the operator

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

Iterator over ordered data

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

Iterator over ordered data

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

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

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

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

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

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

Similar to iter_for_entities but for one entity instead of several

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

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

Returns a component for reading for the passed entity

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

Returns a component for writing for the passed entity

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

Returns true if the entity has the specified component

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

Returns the node for a hierarchical component

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

Returns the node for a hierarchical component for writing

pub fn changed_iter_for<'r, S>(
    &'r self
) -> EntitiesComponentIter<'r, <S as ChangedData<'r>>::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

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

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

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

impl EntitiesStorage for World

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

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

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

pub fn component_mask<C>(&self) -> U256 where
    C: 'static, 

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

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

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

impl ResourcesCreationExt for World

pub fn with_resources_creation<F, R>(&mut self, f: F) -> R where
    F: FnOnce(ResourcesCreation<'_>) -> R, 

pub fn add_resource<T>(&mut self, resource: T) where
    T: 'static + Send, 

Adds a Send resource to the world.

pub fn remove_resource<T>(&mut self) -> Option<T> where
    T: 'static, 

Removes a resource of the specified type.

pub fn add_resource_thread_local<T>(&mut self, resource: T) where
    T: 'static, 

Adds a non Send resource to the world.

pub fn add_resource_as_trait<T, U, F, FMut>(&mut self, resource: (T, F, FMut)) where
    T: 'static + Send,
    F: Fn(&T) -> &U + 'static,
    U: 'static + Send + ?Sized,
    FMut: Fn(&mut T) -> &mut U + 'static, 

Adds a Send resource to the world accessible as a &dyn Trait.

pub fn add_resource_as_trait_thread_local<T, U, F, FMut>(
    &mut self,
    resource: (T, F, FMut)
) where
    T: 'static,
    F: Fn(&T) -> &U + 'static,
    U: 'static + ?Sized,
    FMut: Fn(&mut T) -> &mut U + 'static, 

Adds a non Send resource to the world accessible as a &dyn Trait.

impl ResourcesExt for World

pub fn resource<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static + Send, 

pub fn resource_mut<T>(&self) -> Option<WriteGuardRef<'_, T, ()>> where
    T: 'static + Send, 

pub fn resource_as_trait<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static + Send + ?Sized, 

pub fn resource_as_trait_mut<T>(&self) -> Option<WriteGuardRef<'_, T, ()>> where
    T: 'static + Send + ?Sized, 

impl ResourcesThreadLocalExt for World

pub fn resource_thread_local<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static, 

pub fn resource_thread_local_mut<T>(&self) -> Option<WriteGuardRef<'_, T, ()>> where
    T: 'static, 

pub fn resource_as_trait_thread_local<T>(&self) -> Option<ReadGuardRef<'_, T>> where
    T: 'static + ?Sized, 

pub fn resource_as_trait_thread_local_mut<T>(
    &self
) -> Option<WriteGuardRef<'_, T, ()>> where
    T: 'static + ?Sized,