Struct oxygengine_user_interface::raui::core::animator::AnimatorStates

pub struct AnimatorStates(pub HashMap<String, AnimatorState, RandomState>);

The current state of animations in a component

The AnimatorStates can be accessed from the WidgetContext to get information about the current state of all component animations.

Example

fn my_widget(context: WidgetContext) -> WidgetNode {
    // Get the animator from our context
    let WidgetContext { animator, .. } = context;
     
    // Create the properties for a size box
    let size_box_props = Props::new(SizeBoxProps {
        transform: Transform {
            // Get the `scale` value of the `my_anim` animation or and
            // scale our button based on the animation progress
            scale: Vec2::from(animator.value_progress_factor_or("my_anim", "scale", 1.)),
            ..Default::default()
        },
        ..Default::default()
    });

    // Wrap our button in our animated size box
    widget! { (size_box: {size_box_props} {
        content = (my_button)
    }) }
}

Animations & Values

A component may have any number of different animations identified by a string anim_id. Additionally each animation can have more than one value that is animated and each of these values has a value_name that can be used to get the animated value.

Tuple Fields

0: HashMap<String, AnimatorState, RandomState>

Implementations

impl AnimatorStates

pub fn in_progress(&self) -> bool

Returns whether or not any of the animations for this component are in-progress

pub fn is_done(&self) -> bool

Returns true if none of this component’s animations are currently running

pub fn has(&self, anim_id: &str) -> bool

Returns true if the widget has an animation with the given anim_id

pub fn value_progress(
    &self,
    anim_id: &str,
    value_name: &str
) -> Option<AnimatedValueProgress>

Get the current progress of the animation of a given value

This will return None if the value is not currently being animated.

pub fn value_progress_factor(
    &self,
    anim_id: &str,
    value_name: &str
) -> Option<f32>

Get the current progress factor of the animation of a given value

If the value is currently being animated this will return Some Scalar between 0 and 1 with 0 meaning just started and 1 meaning finished.

If the value is not currently being animated None will be returned

pub fn value_progress_factor_or(
    &self,
    anim_id: &str,
    value_name: &str,
    default: f32
) -> f32

Same as value_progress_factor but returning default instead of None

pub fn value_progress_factor_or_zero(
    &self,
    anim_id: &str,
    value_name: &str
) -> f32

Same as value_progress_factor but returning 0 instead of None

pub fn change(&mut self, anim_id: String, animation: Option<Animation>)

Update the animation with the given anim_id

If animation is None the animation will be removed.

Trait Implementations

impl Clone for AnimatorStates

pub fn clone(&self) -> AnimatorStates

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimatorStates

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

Formats the value using the given formatter.

impl Default for AnimatorStates

pub fn default() -> AnimatorStates

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AnimatorStates

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<AnimatorStates, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for AnimatorStates

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.