move widgets on draw if region size is same

src/util/id.rs

@@ -1,9 +1,4 @@
-/// intentionally does not implement copy or clone
-/// which should make it harder to misuse;
-/// the idea is to generally try to guarantee all IDs
-/// point to something valid, although duplicate
-/// gets around this if needed
-#[derive(Eq, Hash, PartialEq, Debug)]
+#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy)]
 pub struct Id(u64);
 
 #[derive(Default)]
@@ -28,39 +23,3 @@ impl IdTracker {
         self.free.push(id);
     }
 }
-
-impl Id {
-    /// this must be used carefully to make sure
-    /// all IDs are still valid references;
-    /// named weirdly to indicate this.
-    /// generally should not be used in "user" code
-    pub fn duplicate(&self) -> Self {
-        Self(self.0)
-    }
-
-    /// this must be used carefully to make sure
-    /// all IDs are still valid references.
-    /// generally should not be used in "user" code
-    pub fn copyable(&self) -> CopyId {
-        CopyId(self.0)
-    }
-}
-
-#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy)]
-pub struct CopyId(u64);
-
-impl CopyId {
-    pub fn id(&self) -> Id {
-        Id(self.0)
-    }
-}
-
-pub trait IdUtil {
-    fn duplicate(&self) -> Self;
-}
-
-impl IdUtil for Option<Id> {
-    fn duplicate(&self) -> Self {
-        self.as_ref().map(|i| i.duplicate())
-    }
-}

src/util/math.rs

@@ -1,60 +1,82 @@
 use std::ops::*;
 
 #[const_trait]
-pub trait F32Util {
-    fn lerp<T: const Mul<f32, Output = T> + const Add<Output = T>>(self, from: T, to: T) -> T;
+pub trait LerpUtil {
+    fn lerp(self, from: Self, to: Self) -> Self;
+    fn lerp_inv(self, from: Self, to: Self) -> Self;
 }
 
-impl const F32Util for f32 {
-    fn lerp<T: const Mul<f32, Output = T> + const Add<Output = T>>(self, from: T, to: T) -> T {
-        from * (1.0 - self) + to * self
+#[const_trait]
+pub trait DivOr {
+    fn div_or(self, rhs: Self, other: Self) -> Self;
+}
+
+impl const DivOr for f32 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        let res = self / rhs;
+        if res.is_nan() { other } else { res }
+    }
+}
+
+impl<T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy> const
+    LerpUtil for T
+{
+    /// linear interpolation
+    /// from * (1.0 - self) + to * self
+    fn lerp(self, from: Self, to: Self) -> Self {
+        from + (to - from) * self
+    }
+    /// inverse of lerp
+    fn lerp_inv(self, from: Self, to: Self) -> Self {
+        (self - from).div_or(to - from, from)
     }
 }
 
 macro_rules! impl_op {
     ($T:ident $op:ident $fn:ident $opa:ident $fna:ident; $($field:ident)*) => {
-    mod ${concat(op_, $fn, _impl)} {
-        use super::*;
-        #[allow(unused_imports)]
-        use std::ops::*;
-        impl const $op for $T {
-            type Output = Self;
+        #[allow(non_snake_case)]
+        mod ${concat($T, _op_, $fn, _impl)} {
+            use super::*;
+            #[allow(unused_imports)]
+            use std::ops::*;
+            impl const $op for $T {
+                type Output = Self;
 
-            fn $fn(self, rhs: Self) -> Self::Output {
-                Self {
-                    $($field: self.$field.$fn(rhs.$field),)*
+                fn $fn(self, rhs: Self) -> Self::Output {
+                    Self {
+                        $($field: self.$field.$fn(rhs.$field),)*
+                    }
+                }
+            }
+            impl const $opa for $T {
+                fn $fna(&mut self, rhs: Self) {
+                    $(self.$field.$fna(rhs.$field);)*
+                }
+            }
+            impl const $op<f32> for $T {
+                type Output = Self;
+
+                fn $fn(self, rhs: f32) -> Self::Output {
+                    Self {
+                        $($field: self.$field.$fn(rhs),)*
+                    }
+                }
+            }
+            impl const $op<$T> for f32 {
+                type Output = $T;
+
+                fn $fn(self, rhs: $T) -> Self::Output {
+                    $T {
+                        $($field: self.$fn(rhs.$field),)*
+                    }
+                }
+            }
+            impl const $opa<f32> for $T {
+                fn $fna(&mut self, rhs: f32) {
+                    $(self.$field.$fna(rhs);)*
                 }
             }
         }
-        impl const $opa for $T {
-            fn $fna(&mut self, rhs: Self) {
-                $(self.$field.$fna(rhs.$field);)*
-            }
-        }
-        impl const $op<f32> for $T {
-            type Output = Self;
-
-            fn $fn(self, rhs: f32) -> Self::Output {
-                Self {
-                    $($field: self.$field.$fn(rhs),)*
-                }
-            }
-        }
-        impl const $op<$T> for f32 {
-            type Output = $T;
-
-            fn $fn(self, rhs: $T) -> Self::Output {
-                $T {
-                    $($field: self.$fn(rhs.$field),)*
-                }
-            }
-        }
-        impl const $opa<f32> for $T {
-            fn $fna(&mut self, rhs: f32) {
-                $(self.$field.$fna(rhs);)*
-            }
-        }
-    }
     };
     ($T:ident $op:ident $fn:ident; $($field:ident)*) => {
         impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);