Struct AnimationContainer

pub struct AnimationContainer<T>
where
    T: EntityId,
{ /* private fields */ }

A container for animations. It is a tiny wrapper around Pool, you should never create the container yourself, it is managed by the engine.

Implementations

impl<T> AnimationContainer<T>

where T: EntityId,

pub const POOL: &'static str = "pool"

impl<T> AnimationContainer<T>

where T: EntityId,

pub fn new() -> AnimationContainer<T>

Creates an empty animation container.

pub fn alive_count(&self) -> u32

Returns a total amount of animations in the container.

pub fn iter(&self) -> impl Iterator<Item = &Animation<T>>

Returns an iterator yielding a references to animations in the container.

pub fn pair_iter( &self, ) -> impl Iterator<Item = (Handle<Animation<T>>, &Animation<T>)>

Returns an iterator yielding a pair (handle, reference) to animations in the container.

pub fn pair_iter_mut( &mut self, ) -> impl Iterator<Item = (Handle<Animation<T>>, &mut Animation<T>)>

Returns an iterator yielding a pair (handle, reference) to animations in the container.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Animation<T>>

Returns an iterator yielding a references to animations in the container.

pub fn add(&mut self, animation: Animation<T>) -> Handle<Animation<T>>

Adds a new animation to the container and returns its handle.

pub fn remove(&mut self, handle: Handle<Animation<T>>) -> Option<Animation<T>>

Tries to remove an animation from the container by its handle.

pub fn take_reserve( &mut self, handle: Handle<Animation<T>>, ) -> (Ticket<Animation<T>>, Animation<T>)

Extracts animation from container and reserves its handle. It is used to temporarily take ownership over animation, and then put animation back using given ticket.

pub fn put_back( &mut self, ticket: Ticket<Animation<T>>, animation: Animation<T>, ) -> Handle<Animation<T>>

Puts animation back by given ticket.

pub fn forget_ticket(&mut self, ticket: Ticket<Animation<T>>)

Makes animation handle vacant again.

pub fn clear(&mut self)

Removes all animations.

pub fn get(&self, handle: Handle<Animation<T>>) -> &Animation<T>

Tries to borrow a reference to an animation in the container. Panics if the handle is invalid.

pub fn get_mut(&mut self, handle: Handle<Animation<T>>) -> &mut Animation<T>

Tries to borrow a mutable reference to an animation in the container. Panics if the handle is invalid.

pub fn try_get(&self, handle: Handle<Animation<T>>) -> Option<&Animation<T>>

Tries to borrow a reference to an animation in the container.

pub fn try_get_mut( &mut self, handle: Handle<Animation<T>>, ) -> Option<&mut Animation<T>>

Tries to borrow a mutable reference to an animation in the container.

pub fn find_by_name_ref<S>( &self, name: S, ) -> Option<(Handle<Animation<T>>, &Animation<T>)>

where S: AsRef<str>,

Tries to find an animation by its name in the container.

pub fn find_by_name_mut<S>( &mut self, name: S, ) -> Option<(Handle<Animation<T>>, &mut Animation<T>)>

where S: AsRef<str>,

Tries to find an animation by its name in the container.

pub fn retain<P>(&mut self, pred: P)

where P: FnMut(&Animation<T>) -> bool,

Removes every animation from the container that does not satisfy a particular condition represented by the given closue.

pub fn clear_animation_events(&mut self)

Removes queued animation events from every animation in the container.

Potential use cases

Sometimes there is a need to use animation events only from one frame, in this case you should clear events each frame. This situation might come up when you have multiple animations with signals, but at each frame not every event gets processed. This might result in unwanted side effects, like multiple attack events may result in huge damage in a single frame.

Trait Implementations

impl AnimationContainerExt for AnimationContainer<Handle<UiNode>>

fn update_animations(&mut self, ui: &mut UserInterface, dt: f32)

Updates all animations in the container and applies their poses to respective nodes. This method is intended to be used only by the internals of the engine!

impl<T> Clone for AnimationContainer<T>

where T: Clone + EntityId,

fn clone(&self) -> AnimationContainer<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for AnimationContainer<T>

where T: Debug + EntityId,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for AnimationContainer<T>

where T: EntityId,

fn default() -> AnimationContainer<T>

Returns the “default value” for a type.

impl<T> Index<Handle<Animation<T>>> for AnimationContainer<T>

where T: EntityId,

type Output = Animation<T>

The returned type after indexing.

fn index( &self, index: Handle<Animation<T>>, ) -> &<AnimationContainer<T> as Index<Handle<Animation<T>>>>::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Handle<Animation<T>>> for AnimationContainer<T>

where T: EntityId,

fn index_mut( &mut self, index: Handle<Animation<T>>, ) -> &mut <AnimationContainer<T> as Index<Handle<Animation<T>>>>::Output

Performs the mutable indexing (container[index]) operation.

impl<T> PartialEq for AnimationContainer<T>

where T: PartialEq + EntityId,

fn eq(&self, other: &AnimationContainer<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Reflect for AnimationContainer<T>

where T: EntityId, AnimationContainer<T>: 'static, Pool<Animation<T>>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<AnimationContainer<T>>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl<T> Visit for AnimationContainer<T>

where T: EntityId,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl<T> StructuralPartialEq for AnimationContainer<T>

where T: EntityId,