Matej Focko
06243918fc
There was no use-case for returning reference rather than a value and in majority of case the dereference was needed. When using 2D/3D vectors, they are mostly initialized with the numbers and it is contraproductive to pass around references to numbers as they are more expensive than the copies. Signed-off-by: Matej Focko <me@mfocko.xyz>
138 lines
3.4 KiB
Rust
138 lines
3.4 KiB
Rust
use std::cmp::Eq;
|
|
// use std::collections::VecDeque;
|
|
use std::fmt::Debug;
|
|
use std::hash::Hash;
|
|
use std::ops::{Add, /* Index, IndexMut, */ Mul, Sub};
|
|
|
|
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub struct Vector3D<T> {
|
|
x: T,
|
|
y: T,
|
|
z: T,
|
|
}
|
|
|
|
impl<T> Vector3D<T> {
|
|
pub fn new(x: T, y: T, z: T) -> Vector3D<T> {
|
|
Vector3D { x, y, z }
|
|
}
|
|
}
|
|
|
|
impl<T: Copy> Vector3D<T> {
|
|
pub fn x(&self) -> T {
|
|
self.x
|
|
}
|
|
|
|
pub fn y(&self) -> T {
|
|
self.y
|
|
}
|
|
|
|
pub fn z(&self) -> T {
|
|
self.z
|
|
}
|
|
}
|
|
|
|
// [TODO] Implement indexing
|
|
// macro_rules! generate_indices {
|
|
// ($container:ty) => {
|
|
// impl<I, C> Index<Vector3D<I>> for $container
|
|
// where
|
|
// I: Copy + TryInto<usize>,
|
|
// <I as TryInto<usize>>::Error: Debug,
|
|
// C: Index<usize>,
|
|
// {
|
|
// type Output = C::Output;
|
|
|
|
// fn index(&self, index: Vector3D<I>) -> &Self::Output {
|
|
// let (x, y): (usize, usize) =
|
|
// (index.x.try_into().unwrap(), index.y.try_into().unwrap());
|
|
// &self[y][x]
|
|
// }
|
|
// }
|
|
|
|
// impl<I, C> IndexMut<Vector3D<I>> for $container
|
|
// where
|
|
// I: Copy + TryInto<usize>,
|
|
// <I as TryInto<usize>>::Error: Debug,
|
|
// C: IndexMut<usize>,
|
|
// {
|
|
// fn index_mut(&mut self, index: Vector3D<I>) -> &mut Self::Output {
|
|
// let (x, y): (usize, usize) =
|
|
// (index.x.try_into().unwrap(), index.y.try_into().unwrap());
|
|
// &mut self[y][x]
|
|
// }
|
|
// }
|
|
// };
|
|
// }
|
|
|
|
// generate_indices!(VecDeque<C>);
|
|
// generate_indices!([C]);
|
|
// generate_indices!(Vec<C>);
|
|
// // generate_indices!([C; N], const N: usize);
|
|
|
|
// pub fn in_range<I, C>(v: &[Vec<C>], idx: &Vector3D<I>) -> bool
|
|
// where
|
|
// I: Copy,
|
|
// usize: TryFrom<I>,
|
|
// {
|
|
// usize::try_from(idx.y)
|
|
// .and_then(|y| usize::try_from(idx.x).map(|x| y < v.len() && x < v[y].len()))
|
|
// .unwrap_or(false)
|
|
// }
|
|
|
|
// See: https://github.com/rust-lang/rust/issues/102731
|
|
// impl<U: From<T>, T> From<Vector3D<T>> for Vector3D<U> {
|
|
// fn from(value: Vector3D<T>) -> Self {
|
|
// Self {
|
|
// x: U::from(value.x),
|
|
// y: U::from(value.y),
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
impl<T: Add + Add<Output = U>, U> Add for Vector3D<T> {
|
|
type Output = Vector3D<U>;
|
|
|
|
fn add(self, rhs: Self) -> Self::Output {
|
|
Vector3D {
|
|
x: self.x + rhs.x,
|
|
y: self.y + rhs.y,
|
|
z: self.z + rhs.z,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Sub + Sub<Output = U>, U> Sub for Vector3D<T> {
|
|
type Output = Vector3D<U>;
|
|
|
|
fn sub(self, rhs: Self) -> Self::Output {
|
|
Vector3D {
|
|
x: self.x - rhs.x,
|
|
y: self.y - rhs.y,
|
|
z: self.z - rhs.z,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Mul + Mul<Output = U>, U> Mul for Vector3D<T> {
|
|
type Output = Vector3D<U>;
|
|
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
Vector3D {
|
|
x: self.x * rhs.x,
|
|
y: self.y * rhs.y,
|
|
z: self.z * rhs.z,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Mul + Mul<Output = U> + Copy, U> Mul<T> for Vector3D<T> {
|
|
type Output = Vector3D<U>;
|
|
|
|
fn mul(self, rhs: T) -> Self::Output {
|
|
Vector3D {
|
|
x: self.x * rhs,
|
|
y: self.y * rhs,
|
|
z: self.z * rhs,
|
|
}
|
|
}
|
|
}
|