Struct rin_scene::scene::CreationProxy

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

Implementations

impl<'a> CreationProxy<'a>

pub fn new(
    entities: EntitiesCreation<'a>,
    resources: ResourcesCreation<'a>
) -> CreationProxy<'a>

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

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

Trait Implementations

impl<'a> CreationContextExt<'a> for CreationProxy<'a>

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

impl<'a> EntitiesCreationExt<'a> for CreationProxy<'a>

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

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

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

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

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 CreationProxy<'a>

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

Iterator over all the components that match the operator

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

Iterator over all the components that match the operator

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

Iterator over ordered data

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

Iterator over ordered data

fn entity_components<'r, S>(
    &'r self,
    entity: &Entity
) -> Option<S::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::ComponentsRef> where
    S: UnorderedDataSend<'r> + 'r,
    S::Storage: StorageRef<'r, Component = S::ComponentsRef>, 

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 component_for<C: ComponentSend>(&self, entity: &Entity) -> Option<Ptr<'_, C>> where
    C::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::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::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::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::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + ReadOnlyOp<'r> + 'r,
    S::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::Storage> where
    S: ChangedDataSend<'r> + EntitiesData + 'r,
    S::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> ResourcesCreationExt for CreationProxy<'a>

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<'a> ResourcesExt for CreationProxy<'a>

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

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

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

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

impl<'a> ResourcesThreadLocalExt for CreationProxy<'a>

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

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

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

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