aura-anim-core 0.3.0

Typed animation runtime and composable animation sources.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::marker::PhantomData;

use crate::{
    Animatable, AnimationCommand, AnimationState, IntoMotionAnimation, MotionError, MotionRuntime,
};

use super::{MotionId, PlaybackId};

/// A typed handle to an animation stored in a [`MotionRuntime`].
///
/// Handles become invalid after their animation is removed.
#[must_use = "a motion handle is required to access the runtime-managed animation"]
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct Motion<T> {
    id: MotionId,
    marker: PhantomData<fn() -> T>,
}

impl<T> Copy for Motion<T> {}

impl<T> Clone for Motion<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Motion<T> {
    pub(super) fn new(id: MotionId, marker: PhantomData<fn() -> T>) -> Self {
        Self { id, marker }
    }

    pub(super) const fn id(self) -> MotionId {
        self.id
    }

    /// Returns the untyped ID for this motion lifecycle.
    #[must_use]
    pub const fn motion_id(self) -> MotionId {
        self.id
    }
}

impl<T: Animatable> Motion<T> {
    /// Transitions this motion toward `target`.
    pub fn transition_to(self, target: T, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.transition_to(self, target)
    }

    /// Transitions this motion and returns the new playback ID.
    pub fn transition_to_tracked(
        self,
        target: T,
        runtime: &mut MotionRuntime,
    ) -> Result<PlaybackId, MotionError> {
        runtime.transition_to_tracked(self, target)
    }

    /// Replaces this motion's current animation.
    pub fn play<P, Kind>(self, playback: P, runtime: &mut MotionRuntime) -> Result<(), MotionError>
    where
        P: IntoMotionAnimation<T, Kind>,
    {
        runtime.play(self, playback)
    }

    /// Replaces this motion's current animation and returns its playback ID.
    pub fn play_tracked<P, Kind>(
        self,
        playback: P,
        runtime: &mut MotionRuntime,
    ) -> Result<PlaybackId, MotionError>
    where
        P: IntoMotionAnimation<T, Kind>,
    {
        runtime.play_tracked(self, playback)
    }

    /// Clones and returns the current value.
    pub fn value(self, runtime: &MotionRuntime) -> Result<T, MotionError> {
        runtime.value(self).cloned()
    }

    /// Borrows the current value.
    pub fn value_ref(self, runtime: &MotionRuntime) -> Result<&T, MotionError> {
        runtime.value(self)
    }

    /// Returns the current lifecycle state.
    pub fn state(self, runtime: &MotionRuntime) -> Result<AnimationState, MotionError> {
        runtime.state(self)
    }

    /// Returns the ID of this motion's current playback.
    pub fn playback(self, runtime: &MotionRuntime) -> Result<PlaybackId, MotionError> {
        runtime.playback(self)
    }

    /// Returns whether the motion is active.
    pub fn is_active(self, runtime: &MotionRuntime) -> Result<bool, MotionError> {
        runtime.is_active(self)
    }

    /// Returns whether the motion completed.
    pub fn is_completed(self, runtime: &MotionRuntime) -> Result<bool, MotionError> {
        self.state(runtime)
            .map(|state| state == AnimationState::Completed)
    }

    /// Pauses the motion.
    pub fn pause(self, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.command(self, AnimationCommand::Pause)
    }

    /// Resumes the motion.
    pub fn resume(self, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.command(self, AnimationCommand::Resume)
    }

    /// Cancels the motion.
    pub fn cancel(self, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.command(self, AnimationCommand::Cancel)
    }

    /// Seeks the motion to normalized progress.
    pub fn seek(self, progress: f32, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.command(self, AnimationCommand::Seek(progress))
    }

    /// Moves the motion to completion.
    pub fn finish(self, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.command(self, AnimationCommand::Finish)
    }

    /// Removes the motion from the runtime.
    pub fn remove(self, runtime: &mut MotionRuntime) -> Result<(), MotionError> {
        runtime.remove(self)
    }
}