Replace to_f32 and to_f64 with cast

This requires the direct import of the simba library, which used to be
indirectly imported via nalgebra, because nalgebra does not expose
the SupersetOf trait.

Author: patowen

common/Cargo.toml

@@ -23,6 +23,7 @@ tracing-subscriber = { version = "0.3.15", default-features = false, features =
 rand = "0.9.0"
 rand_pcg = "0.9.0"
 rand_distr = "0.5.0"
+simba = "0.9.0"
 
 [dev-dependencies]
 approx = "0.5.1"

common/src/dodeca.rs

@@ -524,16 +524,16 @@ mod data {
         LazyLock::new(|| Vertex::VALUES.map(|vertex| vertex.dual_to_node().parity()));
 
     pub static SIDE_NORMALS_F32: LazyLock<[MVector<f32>; Side::VALUES.len()]> =
-        LazyLock::new(|| SIDE_NORMALS_F64.map(|n| n.to_f32()));
+        LazyLock::new(|| SIDE_NORMALS_F64.map(|n| n.cast()));
 
     pub static REFLECTIONS_F32: LazyLock<[MIsometry<f32>; Side::VALUES.len()]> =
-        LazyLock::new(|| REFLECTIONS_F64.map(|n| n.to_f32()));
+        LazyLock::new(|| REFLECTIONS_F64.map(|n| n.cast()));
 
     pub static DUAL_TO_NODE_F32: LazyLock<[MIsometry<f32>; Vertex::VALUES.len()]> =
-        LazyLock::new(|| DUAL_TO_NODE_F64.map(|n| n.to_f32()));
+        LazyLock::new(|| DUAL_TO_NODE_F64.map(|n| n.cast()));
 
     pub static NODE_TO_DUAL_F32: LazyLock<[MIsometry<f32>; Vertex::VALUES.len()]> =
-        LazyLock::new(|| NODE_TO_DUAL_F64.map(|n| n.to_f32()));
+        LazyLock::new(|| NODE_TO_DUAL_F64.map(|n| n.cast()));
 
     pub static DUAL_TO_CHUNK_FACTOR_F32: LazyLock<f32> =
         LazyLock::new(|| *DUAL_TO_CHUNK_FACTOR_F64 as f32);

common/src/math.rs

@@ -8,6 +8,7 @@
 
 use na::{RealField, Scalar};
 use serde::{Deserialize, Serialize};
+use simba::scalar::SupersetOf;
 use std::ops::*;
 
 /// A stack-allocated 4-dimensional column-vector in Minkowski space. Such
@@ -106,6 +107,12 @@ impl<N: RealField + Copy> MVector<N> {
         self.0 * na::RowVector4::new(other.x, other.y, other.z, -other.w)
     }
 
+    /// Cast the components of `self` to another type.
+    #[inline]
+    pub fn cast<N2: RealField + Copy + SupersetOf<N>>(self) -> MVector<N2> {
+        MVector(self.0.cast())
+    }
+
     /// The column vector with components `[0, 0, 0, 0]`.
     #[inline]
     pub fn zero() -> Self {
@@ -158,20 +165,6 @@ impl<N: RealField + Copy> MVector<N> {
     }
 }
 
-impl MVector<f32> {
-    /// Casts the components to an `f64`
-    pub fn to_f64(self) -> MVector<f64> {
-        MVector(self.0.cast::<f64>())
-    }
-}
-
-impl MVector<f64> {
-    /// Casts the components to an `f32`
-    pub fn to_f32(self) -> MVector<f32> {
-        MVector(self.0.cast::<f32>())
-    }
-}
-
 impl<N: Scalar> Index<usize> for MVector<N> {
     type Output = N;
     #[inline]
@@ -465,19 +458,11 @@ impl<N: RealField + Copy> MIsometry<N> {
         // orientation components.
         normalized_translation_component * normalized_orientation_component
     }
-}
 
-impl MIsometry<f32> {
-    /// Casts the components to an `f64`
-    pub fn to_f64(self) -> MIsometry<f64> {
-        MIsometry(self.0.cast::<f64>())
-    }
-}
-
-impl MIsometry<f64> {
-    /// Casts the components to an `f32`
-    pub fn to_f32(self) -> MIsometry<f32> {
-        MIsometry(self.0.cast::<f32>())
+    /// Cast the components of `self` to another type.
+    #[inline]
+    pub fn cast<N2: RealField + Copy + SupersetOf<N>>(self) -> MIsometry<N2> {
+        MIsometry(self.0.cast())
     }
 }
 

common/src/worldgen.rs

@@ -123,7 +123,7 @@ impl NodeState {
     }
 
     pub fn up_direction(&self) -> MVector<f32> {
-        self.surface.normal().to_f32()
+        self.surface.normal().cast()
     }
 }