Move Point out of cubic splines module and expand it

crates/bevy_color/src/lib.rs

@@ -239,7 +239,7 @@ macro_rules! impl_componentwise_point {
             }
         }
 
-        impl bevy_math::cubic_splines::Point for $ty {}
+        impl bevy_math::VectorSpace for $ty {}
     };
 }
 

crates/bevy_math/src/common_traits.rs

@@ -0,0 +1,133 @@
+use glam::{Quat, Vec2, Vec3, Vec3A, Vec4};
+use std::fmt::Debug;
+use std::ops::{Add, Div, Mul, Sub};
+
+/// A type that supports the mathematical operations of a vector space, irrespective of dimension.
+pub trait VectorSpace:
+    Mul<f32, Output = Self>
+    + Div<f32, Output = Self>
+    + Add<Self, Output = Self>
+    + Sub<Self, Output = Self>
+    + Default
+    + Debug
+    + Clone
+    + Copy
+{
+    /// Perform vector space linear interpolation between this element and another, based
+    /// on the parameter `t`. When `t` is `0`, `self` is recovered. When `t` is `1`, `rhs`
+    /// is recovered.
+    ///
+    /// Note that the value of `t` is not clamped by this function, so interpolating outside
+    /// of the interval `[0,1]` is allowed.
+    #[inline]
+    fn lerp(&self, rhs: Self, t: f32) -> Self {
+        *self * (1. - t) + rhs * t
+    }
+}
+
+impl VectorSpace for Quat {}
+impl VectorSpace for Vec4 {}
+impl VectorSpace for Vec3 {}
+impl VectorSpace for Vec3A {}
+impl VectorSpace for Vec2 {}
+impl VectorSpace for f32 {}
+
+/// A type that supports the operations of a normed vector space; i.e. a norm operation in addition
+/// to those of [`VectorSpace`]. The implementor must guarantee that the axioms of a normed vector
+/// space are satisfied.
+pub trait NormedVectorSpace: VectorSpace {
+    /// The size of this element. The return value should always be nonnegative.
+    fn norm(self) -> f32;
+
+    /// The squared norm of this element. Computing this is often faster than computing
+    /// [`Normed::norm`].
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.norm() * self.norm()
+    }
+
+    /// The distance between this element and another, as determined by the norm.
+    #[inline]
+    fn distance(self, rhs: Self) -> f32 {
+        (rhs - self).norm()
+    }
+
+    /// The squared distance between this element and another, as determined by the norm. Note that
+    /// this is often faster to compute in practice than [`NormedVectorSpace::distance`].
+    #[inline]
+    fn distance_squared(self, rhs: Self) -> f32 {
+        (rhs - self).norm_squared()
+    }
+}
+
+impl NormedVectorSpace for Quat {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.length()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.length_squared()
+    }
+}
+
+impl NormedVectorSpace for Vec4 {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.length()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.length_squared()
+    }
+}
+
+impl NormedVectorSpace for Vec3 {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.length()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.length_squared()
+    }
+}
+
+impl NormedVectorSpace for Vec3A {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.length()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.length_squared()
+    }
+}
+
+impl NormedVectorSpace for Vec2 {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.length()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self.length_squared()
+    }
+}
+
+impl NormedVectorSpace for f32 {
+    #[inline]
+    fn norm(self) -> f32 {
+        self.abs()
+    }
+
+    #[inline]
+    fn norm_squared(self) -> f32 {
+        self * self
+    }
+}