strafe-client/fixed_wide_vectors/src/macros/matrix.rs

// Stolen from https://github.com/c1m50c/fixed-vectors (MIT license)
#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix {
	(
		($struct_outer: ident { $($field_outer: ident), + }, ( $($generic_outer: tt), + ), $size_outer: expr),
		($struct_inner: ident, $size_inner: expr), $fields_inner:tt
	) => {
		impl<T> $struct_outer<$struct_inner<T>> {
			/// Consumes the matrix and returns its values as an array.
			///
			/// # Example
			///
			/// ```
			/// use fixed_wide_vectors::Vector2;
			///
			/// let mat2 = Vector2::new(
			/// 	Vector2::new(0, 0),
			/// 	Vector2::new(0, 0)
			/// );
			/// let array = mat2.to_array_2d();
			///
			/// assert_eq!(array, [[0, 0], [0, 0]]);
			/// ```
			#[inline(always)]
			pub fn to_array_2d(self) -> [[T; $size_inner]; $size_outer] {
				[ $(self.$field_outer.to_array()), + ]
			}

			/// Consumes the matrix and returns its values as a tuple.
			///
			/// # Example
			///
			/// ```
			/// use fixed_wide_vectors::Vector2;
			///
			/// let mat2 = Vector2::new(
			/// 	Vector2::new(0, 0),
			/// 	Vector2::new(0, 0)
			/// );
			/// let tuple = mat2.to_tuple_2d();
			///
			/// assert_eq!(tuple, ((0, 0), (0, 0)));
			/// ```
			#[inline(always)]
			pub fn to_tuple_2d(self) -> ( $($generic_outer), + ) {
				( $(self.$field_outer.to_tuple()), + )
			}

			/// Consumes the matrix and returns a new matrix with the given function applied on each field.
			///
			/// # Example
			///
			/// ```
			/// use fixed_wide_vectors::Vector2;
			///
			/// let mat2 = Vector2::new(
			/// 	Vector2::new(1, 2),
			/// 	Vector2::new(3, 4)
			/// )
			/// .map_2d(|i| i * 2);
			///
			/// assert_eq!(mat2, Vector2::new(Vector2::new(2, 4), Vector2::new(6, 8)));
			/// ```
			#[inline]
			pub fn map_2d<F, U>(self, f: F) -> $struct_outer<$struct_inner<U>>
			where
				F: Fn(T) -> U
			{
				$struct_outer {
					$(
						$field_outer: $crate::matrix_map2d_inner!{f,self,$field_outer,$fields_inner}
					), +
				}
			}

			/// Consumes the matrix and returns a new matrix with the given function applied on each field.
			///
			/// # Example
			///
			/// ```
			/// use fixed_wide_vectors::Vector2;
			///
			/// let mat2 = Vector2::new(
			/// 	Vector2::new(1, 2),
			/// 	Vector2::new(3, 4)
			/// )
			/// .transpose();
			///
			/// assert_eq!(mat2, Vector2::new(Vector2::new(1, 3), Vector2::new(2, 4)));
			/// ```
			#[inline]
			pub fn transpose(self) -> $struct_inner<$struct_outer<T>>{
				$crate::matrix_transpose_outer!{self,$fields_inner,($struct_outer { $($field_outer), + })}
			}
		}

		impl<T: Copy> $struct_outer<$struct_inner<T>> {
			/// Constructs a matrix using the given `value` as the value for all of its fields.
			///
			/// # Example
			///
			/// ```
			/// use fixed_wide_vectors::Vector2;
			///
			/// let mat2 = Vector2::<Vector2<_>>::from_value_2d(0);
			///
			/// assert_eq!(mat2, Vector2::new(Vector2::new(0, 0), Vector2::new(0, 0)));
			/// ```
			#[inline(always)]
			pub const fn from_value_2d(value: T) -> Self {
				Self {
					$( $field_outer: $struct_inner::from_value(value) ), +
				}
			}
			//TODO: diagonal
		}

		// Impl floating-point based methods
		//#[cfg(feature="fixed_wide_traits")]
		//$crate::impl_wide_matrix_operations!( ($struct_outer { $($field_outer), + }, $size_outer), ($struct_inner, $size_inner), $fields_inner );
	};
}


#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! matrix_map2d_inner {
	( $f:ident, $value:ident, $field_outer:ident, ($struct_inner: ident { $($field_inner: ident), + }) ) => {
		$struct_inner {
			$(
				$field_inner: $f($value.$field_outer.$field_inner)
			), +
		}
	}
}
#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! matrix_transpose_outer {
	(
		$value:ident,
		($struct_outer: ident { $($field_outer: ident), + }),
		$fields_inner:tt
	) => {
		$struct_outer {
			$(
				$field_outer: $crate::matrix_transpose_inner!{$value,$field_outer,$fields_inner}
			), +
		}
	}
}
#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! matrix_transpose_inner {
	( $value:ident, $field_outer:ident, ($struct_inner: ident { $($field_inner: ident), + }) ) => {
		$struct_inner {
			$(
				$field_inner: $value.$field_inner.$field_outer
			), +
		}
	}
}

/*
macro_rules! nested {
    (($($f:ident),*) $args:tt) => {
        $(nested!(@call $f $args);)*
    };
    (@call $f:ident ($($arg:expr),*)) => {
        $f($($arg),*);
    };
}

nested! {
    (show1, show2)
    (a, b, c)
}
*/

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix_operator {
	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident, $output: ty ) => {
		impl<T:core::ops::$trait<Output=T>> core::ops::$trait for $struct<T> {
			type Output = $output;

			fn $method(self, other: Self) -> Self::Output {
				Self {
					$( $field: self.$field.$method(other.$field) ), +
				}
			}
		}
		impl<T:core::ops::$trait<Output=T>+Copy> core::ops::$trait<T> for $struct<T>{
			type Output = $output;

			fn $method(self, other: T) -> Self::Output {
				$struct {
					$( $field: self.$field.$method(other) ), +
				}
			}
		}
	};

	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident ) => {
		impl<T: core::ops::$trait> core::ops::$trait for $struct<T> {
			fn $method(&mut self, other: Self)  {
				$( self.$field.$method(other.$field) ); +
			}
		}

		impl<T: core::ops::$trait + Copy> core::ops::$trait<T> for $struct<T> {
			fn $method(&mut self, other: T)  {
				$( self.$field.$method(other) ); +
			}
		}
	};
}