Glam 0.30 (#65)

* Fix Vector4::ONE

* Bump to glam 0.30

* Vector3::slerp()

* manhattan_distance(), chebyshev_distance()

* Matrix4::from_mat3_translation()

* Coverage: swizzle_with

Author: simonask

CHANGELOG.md

@@ -7,13 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-## Breaking changes
+### Fixes
+
+- `Vector4::ONE.w` was accidentally zero.
 
+### Breaking changes
+
+- Bumped `glam` to 0.30. [Changelog](https://github.com/bitshifter/glam-rs/blob/main/CHANGELOG.md#0300---2025-02-18).
 - Bumped `wasmtime` dependency to 29.x.
+- Shuffled trait bounds between `IntUnit` and `IntScalar` to support mapping integers to
+  their unsigned counterparts (needed for `manhattan_distance()` etc.).
 
 ## [0.15.0] - 2024-10-12
 
-## Breaking changes
+### Breaking changes
 
 - Bumped `wasmtime` dependency to 25.0.
 - Bumped `encase` dependency to 0.10.

Cargo.toml

@@ -24,7 +24,7 @@ unexpected_cfgs = { level = "warn", check-cfg = [
 ] }
 
 [dependencies]
-glam = { version = "0.29.0", default-features = false, features = [
+glam = { version = "0.30.0", default-features = false, features = [
     "bytemuck",
     "approx",
 ] }

src/bindings/vec.rs

@@ -2,7 +2,7 @@
 
 use core::ops::Neg;
 
-use crate::Scalar;
+use crate::{scalar::IntScalar, Scalar};
 
 use super::*;
 
@@ -59,14 +59,16 @@ macro_rules! impl_signed_vector {
     };
 }
 
-pub trait IntegerVector: Vector + core::hash::Hash {
+pub trait IntegerVector: Vector<Scalar: IntScalar> + core::hash::Hash {
     crate::interfaces::vector_integer_interface!(trait_decl);
+    crate::interfaces::point_int_interface!(trait_decl);
 }
 
 macro_rules! impl_integer_vector {
     ($glam_ty:ty) => {
         impl IntegerVector for $glam_ty {
             crate::interfaces::vector_integer_interface!(trait_impl);
+            crate::interfaces::point_int_interface!(trait_impl);
         }
     };
 }

src/forward.rs

@@ -250,12 +250,21 @@ macro_rules! forward_fn_assoc {
 ///
 /// The `struct` context is the public API of `glamour`.
 macro_rules! forward_ty {
+    ($mode:tt Option<$thing:tt>) => {
+        Option<crate::forward_ty!($mode $thing)>
+    };
     (trait scalar) => {
         Self::Scalar
     };
     (struct scalar) => {
         T::Scalar
     };
+    (trait uscalar) => {
+        <Self::Scalar as crate::scalar::IntScalar>::Unsigned
+    };
+    (struct uscalar) => {
+        <T::Scalar as crate::scalar::IntScalar>::Unsigned
+    };
     (trait angle) => {
         Self::Scalar
     };
@@ -456,12 +465,18 @@ macro_rules! forward_arg {
 }
 
 macro_rules! wrap_ret_val {
+    (Option<$thing:tt> => $arg:expr) => {
+        $arg
+    };
     ($arg:expr) => {
         $arg
     };
     ( scalar => $arg:expr) => {
         $arg
     };
+    ( uscalar => $arg:expr) => {
+        $arg
+    };
     ( angle => $arg:expr) => {
         crate::wrap($arg)
     };

src/impl_vectorlike.rs

@@ -205,7 +205,7 @@ macro_rules! simdlike {
             /// All zeroes.
             pub const ZERO: Self = Self::new(T::Scalar::ZERO, T::Scalar::ZERO, T::Scalar::ZERO, T::Scalar::ZERO);
             /// All ones.
-            pub const ONE: Self = Self::new(T::Scalar::ONE, T::Scalar::ONE, T::Scalar::ONE, T::Scalar::ZERO);
+            pub const ONE: Self = Self::new(T::Scalar::ONE, T::Scalar::ONE, T::Scalar::ONE, T::Scalar::ONE);
 
             /// Unit vector in the direction of the X axis.
             pub const X: Self = Self::new(
@@ -376,6 +376,9 @@ macro_rules! pointlike {
         impl<T: crate::FloatUnit> $base_type_name<T> {
             crate::interfaces::point_float_interface!(struct);
         }
+        impl<T: crate::IntUnit<Scalar: crate::scalar::IntScalar>> $base_type_name<T> {
+            crate::interfaces::point_int_interface!(struct);
+        }
     };
     (@for_size $base_type_name:ident, 2) => {
         impl<T: crate::Unit> $base_type_name<T> {
@@ -397,6 +400,7 @@ macro_rules! pointlike {
     };
 }
 pub(crate) use pointlike;
+
 macro_rules! sizelike {
     ($base_type_name:ident, $n:tt) => {
         crate::impl_vectorlike::simdlike!($base_type_name, $n);

src/interfaces.rs

@@ -228,6 +228,22 @@ macro_rules! point_float_interface {
 }
 pub(crate) use point_float_interface;
 
+/// Interface for all geometric point-like things with integer components.
+macro_rules! point_int_interface {
+    ($mode:tt) => {
+        crate::interface! {
+            $mode =>
+            /// Computes the manhattan distance between two points
+            fn manhattan_distance(self, other: Self) -> uscalar;
+            /// Computes the manhattan distance between two points
+            fn checked_manhattan_distance(self, other: Self) -> Option<uscalar>;
+            /// Compute the chebyshev distance between two points.
+            fn chebyshev_distance(self, other: Self) -> uscalar;
+        }
+    };
+}
+pub(crate) use point_int_interface;
+
 macro_rules! simd2_base_interface {
     ($mode:tt, $larger:tt) => {
         crate::interface! {
@@ -416,6 +432,8 @@ macro_rules! vector3_float_interface {
             fn any_orthonormal_vector(&self) -> Self;
             /// See (e.g.) [`glam::Vec3::any_orthonormal_pair()`].
             fn any_orthonormal_pair(&self) -> (Self, Self);
+            /// Performs a spherical linear interpolation between `self` and `rhs` based on the value `s`.
+            fn slerp(self, rhs: Self, s: scalar) -> Self;
         }
     };
 }
@@ -778,6 +796,9 @@ macro_rules! matrix4_base_interface {
             fn to_cols_array_2d(&self) -> [[scalar; 4]; 4];
             /// Creates a 4x4 matrix from a `[T; 16]` array stored in column major order.
             fn from_cols_array(array: ref_scalar_array_16) -> Self;
+            /// Creates an affine transformation matrics from a 3x3 matrix (expressing scale, shear and rotation) and a
+            /// translation vector.
+            fn from_mat3_translation(mat3: mat3, translation: vec3) -> Self;
         }
     }
 }

src/point.rs

@@ -414,6 +414,27 @@ mod tests {
         assert_eq!(p4, point!(1.0, 2.0, 3.0, 4.0));
     }
 
+    #[test]
+    fn manhattan_distance() {
+        let a: Point3<i16> = point![1, 1, 1];
+        let b: Point3<i16> = point![2, 2, 2];
+        let d: u16 = a.manhattan_distance(b);
+        assert_eq!(d, 3);
+
+        let a: Point3<i16> = point![0, 0, 0];
+        let b: Point3<i16> = point![i16::MAX, i16::MAX, 2];
+        let d: Option<u16> = a.checked_manhattan_distance(b);
+        assert_eq!(d, None);
+    }
+
+    #[test]
+    fn chebyshev_distance() {
+        let a: Point3<i16> = point![1, 1, 1];
+        let b: Point3<i16> = point![2, 2, 3];
+        let d: u16 = a.chebyshev_distance(b);
+        assert_eq!(d, 2);
+    }
+
     #[test]
     fn gaslight_coverage() {
         extern crate alloc;

src/scalar.rs

@@ -109,9 +109,8 @@ pub unsafe trait FloatScalar:
 }
 
 /// Integer scalar types.
-pub trait IntScalar:
-    Scalar<Vec2: bindings::IntegerVector, Vec3: bindings::IntegerVector, Vec4: bindings::IntegerVector>
-{
+pub trait IntScalar: Scalar + num_traits::PrimInt {
+    type Unsigned: IntScalar + num_traits::Unsigned;
 }
 
 unsafe impl Scalar for f32 {
@@ -160,7 +159,9 @@ unsafe impl Scalar for i16 {
     type Vec4 = glam::I16Vec4;
 }
 
-impl IntScalar for i16 {}
+impl IntScalar for i16 {
+    type Unsigned = u16;
+}
 
 impl SignedScalar for i16 {
     const NEG_ONE: Self = -1;
@@ -172,7 +173,9 @@ unsafe impl Scalar for i32 {
     type Vec4 = glam::IVec4;
 }
 
-impl IntScalar for i32 {}
+impl IntScalar for i32 {
+    type Unsigned = u32;
+}
 
 impl SignedScalar for i32 {
     const NEG_ONE: Self = -1;
@@ -184,7 +187,9 @@ unsafe impl Scalar for i64 {
     type Vec4 = glam::I64Vec4;
 }
 
-impl IntScalar for i64 {}
+impl IntScalar for i64 {
+    type Unsigned = u64;
+}
 
 impl SignedScalar for i64 {
     const NEG_ONE: Self = -1;
@@ -196,23 +201,29 @@ unsafe impl Scalar for u16 {
     type Vec4 = glam::U16Vec4;
 }
 
-impl IntScalar for u16 {}
+impl IntScalar for u16 {
+    type Unsigned = u16;
+}
 
 unsafe impl Scalar for u32 {
     type Vec2 = glam::UVec2;
     type Vec3 = glam::UVec3;
     type Vec4 = glam::UVec4;
 }
 
-impl IntScalar for u32 {}
+impl IntScalar for u32 {
+    type Unsigned = u32;
+}
 
 unsafe impl Scalar for u64 {
     type Vec2 = glam::U64Vec2;
     type Vec3 = glam::U64Vec3;
     type Vec4 = glam::U64Vec4;
 }
 
-impl IntScalar for u64 {}
+impl IntScalar for u64 {
+    type Unsigned = u64;
+}
 
 #[cfg(test)]
 mod tests {