Struct Animator

pub struct Animator<T: Component> {
    pub state: AnimatorState,
    pub target: Option<Entity>,
    /* private fields */
}

Component to control the animation of another component.

By default, the animated component is the component located on the same entity as the Animator<T> itself. But if Animator::target is set, that entity will be used instead.

Fields

state: AnimatorState

Control if this animation is played or not.

target: Option<Entity>

When set, the animated component will be the one located on this entity.

Implementations

impl<T: Component> Animator<T>

pub fn new(tween: impl Tweenable<T> + 'static) -> Self

Create a new animator component from a single tweenable.

pub fn with_target(self, entity: Entity) -> Self

Create a new version of this animator with the target set to the given entity.

pub fn with_state(self, state: AnimatorState) -> Self

Set the initial playback state of the animator.

pub fn with_speed(self, speed: f32) -> Self

Set the initial speed of the animator. See Animator::set_speed for details.

pub fn set_speed(&mut self, speed: f32)

Set the animation speed. Defaults to 1.

A speed of 2 means the animation will run twice as fast while a speed of 0.1 will result in a 10x slowed animation.

pub fn speed(&self) -> f32

Get the animation speed.

See set_speed() for a definition of what the animation speed is.

pub fn set_tweenable(&mut self, tween: impl Tweenable<T> + 'static)

Set the top-level tweenable item this animator controls.

pub fn tweenable(&self) -> &dyn Tweenable<T>

Get the top-level tweenable this animator is currently controlling.

pub fn tweenable_mut(&mut self) -> &mut dyn Tweenable<T>

Get the top-level mutable tweenable this animator is currently controlling.

pub fn stop(&mut self)

Stop animation playback and rewind the animation.

This changes the animator state to AnimatorState::Paused and rewind its tweenable.

Trait Implementations

impl<T: Component> Component for Animator<T>

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl<T: Component + Debug> Debug for Animator<T>

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

Formats the value using the given formatter.