Move Point out of cubic splines module and expand it

crates/bevy_color/src/laba.rs

@@ -1,6 +1,6 @@
 use crate::{
-    impl_componentwise_point, Alpha, ClampColor, Hsla, Hsva, Hwba, LinearRgba, Luminance, Mix,
-    Oklaba, Srgba, StandardColor, Xyza,
+    impl_componentwise_vector_space, Alpha, ClampColor, Hsla, Hsva, Hwba, LinearRgba, Luminance,
+    Mix, Oklaba, Srgba, StandardColor, Xyza,
 };
 use bevy_reflect::prelude::*;
 
@@ -29,7 +29,7 @@ pub struct Laba {
 
 impl StandardColor for Laba {}
 
-impl_componentwise_point!(Laba, [lightness, a, b, alpha]);
+impl_componentwise_vector_space!(Laba, [lightness, a, b, alpha]);
 
 impl Laba {
     /// Construct a new [`Laba`] color from components.

crates/bevy_color/src/lib.rs

@@ -163,7 +163,7 @@ where
 {
 }
 
-macro_rules! impl_componentwise_point {
+macro_rules! impl_componentwise_vector_space {
     ($ty: ident, [$($element: ident),+]) => {
         impl std::ops::Add<Self> for $ty {
             type Output = Self;
@@ -181,6 +181,16 @@ macro_rules! impl_componentwise_point {
             }
         }
 
+        impl std::ops::Neg for $ty {
+            type Output = Self;
+
+            fn neg(self) -> Self::Output {
+                Self::Output {
+                    $($element: -self.$element,)+
+                }
+            }
+        }
+
         impl std::ops::Sub<Self> for $ty {
             type Output = Self;
 
@@ -239,8 +249,12 @@ macro_rules! impl_componentwise_point {
             }
         }
 
-        impl bevy_math::cubic_splines::Point for $ty {}
+        impl bevy_math::VectorSpace for $ty {
+            const ZERO: Self = Self {
+                $($element: 0.0,)+
+            };
+        }
     };
 }
 
-pub(crate) use impl_componentwise_point;
+pub(crate) use impl_componentwise_vector_space;

crates/bevy_color/src/linear_rgba.rs

@@ -1,6 +1,6 @@
 use crate::{
-    color_difference::EuclideanDistance, impl_componentwise_point, Alpha, ClampColor, Luminance,
-    Mix, StandardColor,
+    color_difference::EuclideanDistance, impl_componentwise_vector_space, Alpha, ClampColor,
+    Luminance, Mix, StandardColor,
 };
 use bevy_math::Vec4;
 use bevy_reflect::prelude::*;
@@ -32,7 +32,7 @@ pub struct LinearRgba {
 
 impl StandardColor for LinearRgba {}
 
-impl_componentwise_point!(LinearRgba, [red, green, blue, alpha]);
+impl_componentwise_vector_space!(LinearRgba, [red, green, blue, alpha]);
 
 impl LinearRgba {
     /// A fully black color with full alpha.

crates/bevy_color/src/oklaba.rs

@@ -1,6 +1,6 @@
 use crate::{
-    color_difference::EuclideanDistance, impl_componentwise_point, Alpha, ClampColor, Hsla, Hsva,
-    Hwba, Lcha, LinearRgba, Luminance, Mix, Srgba, StandardColor, Xyza,
+    color_difference::EuclideanDistance, impl_componentwise_vector_space, Alpha, ClampColor, Hsla,
+    Hsva, Hwba, Lcha, LinearRgba, Luminance, Mix, Srgba, StandardColor, Xyza,
 };
 use bevy_reflect::prelude::*;
 
@@ -29,7 +29,7 @@ pub struct Oklaba {
 
 impl StandardColor for Oklaba {}
 
-impl_componentwise_point!(Oklaba, [lightness, a, b, alpha]);
+impl_componentwise_vector_space!(Oklaba, [lightness, a, b, alpha]);
 
 impl Oklaba {
     /// Construct a new [`Oklaba`] color from components.

crates/bevy_color/src/srgba.rs

@@ -1,6 +1,7 @@
 use crate::color_difference::EuclideanDistance;
 use crate::{
-    impl_componentwise_point, Alpha, ClampColor, LinearRgba, Luminance, Mix, StandardColor, Xyza,
+    impl_componentwise_vector_space, Alpha, ClampColor, LinearRgba, Luminance, Mix, StandardColor,
+    Xyza,
 };
 use bevy_math::Vec4;
 use bevy_reflect::prelude::*;
@@ -31,7 +32,7 @@ pub struct Srgba {
 
 impl StandardColor for Srgba {}
 
-impl_componentwise_point!(Srgba, [red, green, blue, alpha]);
+impl_componentwise_vector_space!(Srgba, [red, green, blue, alpha]);
 
 impl Srgba {
     // The standard VGA colors, with alpha set to 1.0.

crates/bevy_color/src/xyza.rs

@@ -1,5 +1,5 @@
 use crate::{
-    impl_componentwise_point, Alpha, ClampColor, LinearRgba, Luminance, Mix, StandardColor,
+    impl_componentwise_vector_space, Alpha, ClampColor, LinearRgba, Luminance, Mix, StandardColor,
 };
 use bevy_reflect::prelude::*;
 
@@ -28,7 +28,7 @@ pub struct Xyza {
 
 impl StandardColor for Xyza {}
 
-impl_componentwise_point!(Xyza, [x, y, z, alpha]);
+impl_componentwise_vector_space!(Xyza, [x, y, z, alpha]);
 
 impl Xyza {
     /// Construct a new [`Xyza`] color from components.

crates/bevy_math/src/common_traits.rs

@@ -0,0 +1,180 @@
+use glam::{Quat, Vec2, Vec3, Vec3A, Vec4};
+use std::fmt::Debug;
+use std::ops::{Add, Div, Mul, Neg, Sub};
+
+/// A type that supports the mathematical operations of a real vector space, irrespective of dimension.
+/// In particular, this means that the implementing type supports:
+/// - Scalar multiplication and division on the right by elements of `f32`
+/// - Negation
+/// - Addition and subtraction
+/// - Zero
+///
+/// Within the limitations of floating point arithmetic, all the following are required to hold:
+/// - (Associativity of addition) For all `u, v, w: Self`, `(u + v) + w == u + (v + w)`.
+/// - (Commutativity of addition) For all `u, v: Self`, `u + v == v + u`.
+/// - (Additive identity) For all `v: Self`, `v + Self::ZERO == v`.
+/// - (Additive inverse) For all `v: Self`, `v - v == v + (-v) == Self::ZERO`.
+/// - (Compatibility of multiplication) For all `a, b: f32`, `v: Self`, `v * (a * b) == (v * a) * b`.
+/// - (Multiplicative identity) For all `v: Self`, `v * 1.0 == v`.
+/// - (Distributivity for vector addition) For all `a: f32`, `u, v: Self`, `(u + v) * a == u * a + v * a`.
+/// - (Distributivity for scalar addition) For all `a, b: f32`, `v: Self`, `v * (a + b) == v * a + v * b`.
+///
+/// Note that, because implementing types use floating point arithmetic, they are not required to actually
+/// implement `PartialEq` or `Eq`.
+pub trait VectorSpace:
+    Mul<f32, Output = Self>
+    + Div<f32, Output = Self>
+    + Add<Self, Output = Self>
+    + Sub<Self, Output = Self>
+    + Neg
+    + Default
+    + Debug
+    + Clone
+    + Copy
+{
+    /// The zero vector, which is the identity of addition for the vector space type.
+    const ZERO: Self;
+
+    /// 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
+    }
+}
+
+// This is cursed and we should probably remove Quat from these.
+impl VectorSpace for Quat {
+    const ZERO: Self = Quat::from_xyzw(0., 0., 0., 0.);
+}
+
+impl VectorSpace for Vec4 {
+    const ZERO: Self = Vec4::ZERO;
+}
+
+impl VectorSpace for Vec3 {
+    const ZERO: Self = Vec3::ZERO;
+}
+
+impl VectorSpace for Vec3A {
+    const ZERO: Self = Vec3A::ZERO;
+}
+
+impl VectorSpace for Vec2 {
+    const ZERO: Self = Vec2::ZERO;
+}
+
+impl VectorSpace for f32 {
+    const ZERO: Self = 0.0;
+}
+
+/// A type that supports the operations of a normed vector space; i.e. a norm operation in addition
+/// to those of [`VectorSpace`]. Specifically, the implementor must guarantee that the following
+/// relationships hold, within the limitations of floating point arithmetic:
+/// - (Nonnegativity) For all `v: Self`, `v.norm() >= 0.0`.
+/// - (Positive definiteness) For all `v: Self`, `v.norm() == 0.0` implies `v == Self::ZERO`.
+/// - (Absolute homogeneity) For all `c: f32`, `v: Self`, `(v * c).norm() == v.norm() * c.abs()`.
+/// - (Triangle inequality) For all `v, w: Self`, `(v + w).norm() <= v.norm() + w.norm()`.
+///
+/// Note that, because implementing types use floating point arithmetic, they are not required to actually
+/// implement `PartialEq` or `Eq`.
+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
+    /// [`NormedVectorSpace::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
+    }
+}