tempa 0.1.10

A no_std temporal system for animation and simulation, providing time, duration, time ranges, frame rates, and deterministic frame-index stepping.
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use core::ops::Div;

use rinia::{
    Scalard, Scalarf,
    numeric::{IsFinite, LossyCastFrom, One, Zero},
};

use crate::{Duration, Error, FrameRate, common};

impl<T> FrameRate<T> {
    /// Creates a [FrameRate] from frames per second without validation.
    ///
    /// This function allows invalid values (not finite, or non-positive) to be used,
    /// which may lead to invalid results in subsequent calculations.
    ///
    /// Prefer [Self::from_fps] for validated construction.
    #[inline]
    pub const fn new(fps: T) -> Self {
        Self(fps)
    }

    /// Creates [FrameRate] from frames per second with validation.
    ///
    /// Returns an error if fps is not finite, or non-positive.
    #[inline]
    pub fn try_from_fps(fps: T) -> Result<Self, Error>
    where
        T: Copy + IsFinite + PartialOrd + Zero,
    {
        if !fps.is_finite() {
            return Err(Error::InvalidValue(
                "FrameRate cannot be created from NaN or infinite values",
            ));
        }

        if fps <= T::ZERO {
            return Err(Error::InvalidValue(
                "FrameRate cannot be created from non-positive values",
            ));
        }

        Ok(Self(fps))
    }

    /// Creates a [FrameRate] from frames per second with validation.
    ///
    /// # Panics
    /// Panics if fps is not finite, or non-positive.
    #[inline]
    pub fn from_fps(fps: T) -> Self
    where
        T: Copy + IsFinite + PartialOrd + Zero,
    {
        Self::try_from_fps(fps).unwrap_or_else(|err| panic!("{err}"))
    }

    /// Returns frames per second.
    #[inline]
    pub fn fps(&self) -> T
    where
        T: Copy,
    {
        self.0
    }

    /// Consumes this [FrameRate] value and returns the inner frames per second value.
    #[inline]
    pub fn into_fps(self) -> T {
        self.0
    }

    /// Returns seconds per frame.
    #[inline]
    pub fn seconds_per_frame(&self) -> T
    where
        T: Copy + One + Div<Output = T>,
    {
        T::ONE / self.0
    }

    /// Consumes this [FrameRate] value and returns the seconds per frame value.
    #[inline]
    pub fn into_seconds_per_frame(self) -> T
    where
        T: One + Div<Output = T>,
    {
        T::ONE / self.0
    }

    /// Returns the duration of one frame as [Duration].
    #[inline]
    pub fn duration(&self) -> Duration<T>
    where
        T: Copy + One + Div<Output = T>,
    {
        Duration::new(self.seconds_per_frame())
    }

    /// Consumes this [FrameRate] value and returns the duration of one frame as [Duration].
    #[inline]
    pub fn into_duration(self) -> Duration<T>
    where
        T: One + Div<Output = T>,
    {
        Duration::new(self.into_seconds_per_frame())
    }

    /// Returns the dimensionless ratio of this frame rate to another.
    #[inline]
    pub fn ratio(&self, other: FrameRate<T>) -> T
    where
        T: Copy + Div<Output = T>,
    {
        *self / other
    }
}

// Default
impl<T> Default for FrameRate<T>
where
    T: LossyCastFrom<u16>,
{
    #[inline]
    fn default() -> Self {
        Self::fps_60()
    }
}

// Impl common frame rate constructors
crate::frame_rate::impl_rate_fps!(24, 25, 30, 48, 50, 60, 120, 144, 240);

// Impl approx equality traits for FrameRate<T>
common::impl_approx_forwarding!(FrameRate<T>, 0);

// Impl bytemuck for FrameRate<T>
common::impl_bytemuck_basic!(
    [T],
    FrameRate<T>,
    item: T,
);

// Conversion
impl<T> From<T> for FrameRate<T> {
    #[inline]
    fn from(value: T) -> Self {
        Self::new(value)
    }
}

impl From<FrameRate<Scalarf>> for Scalarf {
    #[inline]
    fn from(frame_rate: FrameRate<Scalarf>) -> Self {
        frame_rate.fps()
    }
}

impl From<FrameRate<Scalard>> for Scalard {
    #[inline]
    fn from(frame_rate: FrameRate<Scalard>) -> Self {
        frame_rate.fps()
    }
}