some impls

src/lib.rs

@@ -1,15 +1,63 @@
+#[cfg(test)]
+mod tests;
+
 pub struct Tween<T> {
-    tweeners: Vec<Tweener<T>>,
+    tweeners: Vec<(f32, Tweener<T>)>,
+    time: f32,
+    current_tweener: usize,
 }
 
 pub enum Tweener<T> {
     TweenFunction {
         function: fn(t: f32, min: T, max: T) -> T,
+        duration: f32,
     },
     TweenInterval {
-        interval: f32,
+        duration: f32,
     },
     TweenCallback {
         callback: fn(),
     },
 }
+
+impl<T> Tweener<T> {
+    pub fn duration(&self) -> f32 {
+        match self {
+            Tweener::TweenFunction { function, duration } => duration.clone(),
+            Tweener::TweenInterval { duration } => duration.clone(),
+            Tweener::TweenCallback { callback } => 0f32,
+        }
+    }
+    pub fn is_completed(&self, time: f32) -> bool {
+        match self {
+            Tweener::TweenFunction { function, duration } => *duration >= time,
+            Tweener::TweenInterval { duration } => *duration >= time,
+            Tweener::TweenCallback { callback } => true,
+        }
+    }
+}
+impl<T> Tween<T> {
+    pub fn new() -> Self {
+        Self {
+            tweeners: vec![],
+            time: 0f32,
+            current_tweener: 0,
+        }
+    }
+
+    pub fn add_tweener(&mut self, tweener: Tweener<T>) {
+        self.tweeners.push((self.duration(), tweener));
+    }
+    #[inline]
+    pub fn duration(&self) -> f32 {
+        self.tweeners.iter().map(|el| el.1.duration()).sum::<f32>()
+    }
+    pub fn is_completed(&self) -> bool {
+        self.duration() <= self.time
+    }
+    pub fn step(&mut self, delta: f32) {
+        //for (offset,tween) in self.tweeners.iter().step_by(self.current_tweener) {
+        //    if tween
+        //}
+    }
+}

src/tests.rs

@@ -0,0 +1 @@
+