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

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix {
	() => {
		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>{
			#[inline(always)]
			pub const fn new(array:[[T;Y];X])->Self{
				Self{array}
			}
			#[inline(always)]
			pub fn to_array(self)->[[T;Y];X]{
				self.array
			}
			#[inline]
			pub fn map<F,U>(self,f:F)->Matrix<X,Y,U>
			where
				F:Fn(T)->U
			{
				Matrix{
					array:self.array.map(|inner|inner.map(&f)),
				}
			}
		}
		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>
		where
			T:Copy
		{
			pub const fn from_value(value:T)->Self{
				Self{
					array:[[value;Y];X]
				}
			}
		}

		impl<const X:usize,const Y:usize,T:Default> Default for Matrix<X,Y,T>{
			fn default()->Self{
				Self{
					array:core::array::from_fn(|_|core::array::from_fn(|_|Default::default()))
				}
			}
		}
	}
}

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix_named_fields_shape {
	(
		($struct_outer:ident, $size_outer: expr),
		($struct_inner:ident, $size_inner: expr)
	) => {
		impl<T> core::ops::Deref for Matrix<$size_outer,$size_inner,T>{
			type Target=$struct_outer<$struct_inner<T>>;
			fn deref(&self)->&Self::Target{
				unsafe{core::mem::transmute(&self.array)}
			}
		}
		impl<T> core::ops::DerefMut for Matrix<$size_outer,$size_inner,T>{
			fn deref_mut(&mut self)->&mut Self::Target{
				unsafe{core::mem::transmute(&mut self.array)}
			}
		}
	}
}

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix_named_fields_shape_shim {
	(
		($($vector_info:tt),+),
		$matrix_info:tt
	) => {
		$crate::macro_repeated!(impl_matrix_named_fields_shape,$matrix_info,$($vector_info),+);
	}
}

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix_named_fields {
	(
		($($matrix_info:tt),+),
		$vector_infos:tt
	) => {
		$crate::macro_repeated!(impl_matrix_named_fields_shape_shim,$vector_infos,$($matrix_info),+);
	}
}