gfxmath_vec2/
vec2.rs

1#[repr(C)]
2#[derive(Debug, Clone, PartialEq)]
3pub struct Vec2<T> {
4    pub x: T,
5    pub y: T
6}
7
8impl <T> Eq for Vec2<T> where T: PartialEq {}
9
10impl <T> Vec2 <T> {
11    #[inline]
12    pub fn new(x: T, y: T) -> Self {
13        Self { x, y }
14    }
15
16    pub fn as_ptr(&self) -> *const T {
17        self as *const _ as *const T
18    }
19
20    pub fn as_mut_ptr(&mut self) -> *mut T {
21        self as *mut _ as *mut T
22    }
23
24        ///
25    /// ```
26    /// use gfxmath_vec2::Vec2;
27    /// 
28    /// let a = Vec2::<f32>::new(1.0, 2.0);
29    /// 
30    /// let a_slice = a.as_slice();
31    /// 
32    /// assert_eq!(1.0, a_slice[0]);
33    /// assert_eq!(2.0, a_slice[1]);
34    /// ```
35    pub fn as_slice(&self) -> &[T] {
36        unsafe { std::slice::from_raw_parts(self.as_ptr(), 2) }
37    }
38
39    ///
40    /// ```
41    /// use gfxmath_vec2::Vec2;
42    /// 
43    /// let mut a = Vec2::<f32>::new(1.0, 2.0);
44    /// 
45    /// {
46    ///     let a_slice = a.as_mut_slice();
47    /// 
48    ///     assert_eq!(1.0, a_slice[0]);
49    ///     assert_eq!(2.0, a_slice[1]);
50    /// 
51    ///     a_slice[1] = 108.0;
52    ///     assert_eq!(108.0, a_slice[1]); 
53    /// }
54    /// 
55    /// a.x = 4.5;
56    /// assert_eq!(4.5, a.x);
57    /// 
58    /// let a_slice = a.as_mut_slice();
59    /// 
60    /// assert_eq!(4.5, a_slice[0]);
61    /// assert_eq!(108.0, a_slice[1]);
62    /// ```
63    pub fn as_mut_slice(&mut self) -> &mut [T] {
64        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), 2) }
65    }
66}
67
68impl <T> Vec2<T> where T: Clone {
69    /// ```
70    /// use gfxmath_vec2::Vec2;
71    /// 
72    /// let v = Vec2::<f32>::all(2.5);
73    /// 
74    /// assert_eq!(2.5, v.x);
75    /// assert_eq!(2.5, v.y);
76    /// ```
77    #[inline]
78    pub fn all(val: T) -> Self {
79        Self::new(val.clone(), val.clone())
80    }
81}
82
83///
84/// ```
85/// use gfxmath_vec2::Vec2;
86/// 
87/// let v: Vec2<f32> = (3.0, 2.0).into();
88/// 
89/// assert_eq!(3.0, v.x);
90/// assert_eq!(2.0, v.y);
91/// ```
92impl <T> From<(T, T)> for Vec2<T> {
93    fn from(val: (T, T)) -> Self {
94        Vec2::new(val.0, val.1)
95    }
96}
97
98///
99/// ```
100/// use gfxmath_vec2::Vec2;
101/// 
102/// let v0 = (3.0, 2.0);
103/// 
104/// let v: Vec2<f32> = (&v0).into();
105/// 
106/// assert_eq!(3.0, v.x);
107/// assert_eq!(2.0, v.y);
108/// ```
109impl <T> From<&(T, T)> for Vec2<T> where T: Clone {
110    fn from(val: &(T, T)) -> Self {
111        Vec2::new(val.0.clone(), val.1.clone())
112    }
113}
114
115///
116/// ```
117/// use gfxmath_vec2::Vec2;
118/// 
119/// let v = Vec2::new(3.0, 2.0);
120/// let v: (f32, f32) = v.into();
121/// 
122/// assert_eq!(3.0, v.0);
123/// assert_eq!(2.0, v.1);
124/// 
125/// ```
126impl <T> From<Vec2<T>> for (T, T) {
127    fn from(val: Vec2<T>) -> Self {
128        (val.x, val.y)
129    }
130}
131
132///
133/// ```
134/// use gfxmath_vec2::Vec2;
135/// 
136/// let v = Vec2::new(3.0, 2.0);
137/// let v: (f32, f32) = (&v).into();
138/// 
139/// assert_eq!(3.0, v.0);
140/// assert_eq!(2.0, v.1);
141/// ```
142impl <T> From<&Vec2<T>> for (T, T) where T: Clone {
143    fn from(val: &Vec2<T>) -> Self {
144        (val.x.clone(), val.y.clone())
145    }
146}
147
148/// ```
149/// use gfxmath_vec2::{Vec2, vec2};
150/// let v = vec2!(2.0, 3.0);
151/// assert_eq!(2.0, v.x);
152/// assert_eq!(3.0, v.y);
153/// ```
154#[macro_export]
155macro_rules! vec2 {
156    ($x: expr, $y: expr) => {
157        {
158            Vec2::new($x, $y)
159        }
160    }
161}
gfxmath_vec2/vec2.rs

gfxmath_vec2/
vec2.rs
