gfxmath_vec4/
vec4.rs

1#[repr(C)]
2#[derive(Debug, Clone, PartialEq)]
3pub struct Vec4<T> {
4    pub x: T,
5    pub y: T,
6    pub z: T,
7    pub w: T
8}
9
10impl <T> Vec4 <T> {
11    pub fn new(x: T, y: T, z: T, w: T) -> Self {
12        Self { x, y, z, w }
13    }
14
15    pub fn as_ptr(&self) -> *const T {
16        self as *const _ as *const T
17    }
18
19    pub fn as_mut_ptr(&mut self) -> *mut T {
20        self as *mut _ as *mut T
21    }
22
23    ///
24    /// ```
25    /// use gfxmath_vec4::Vec4;
26    /// 
27    /// let a = Vec4::<f32>::new(1.0, 2.0, 3.0, 4.0);
28    /// 
29    /// let a_slice = a.as_slice();
30    /// 
31    /// assert_eq!(1.0, a_slice[0]);
32    /// assert_eq!(2.0, a_slice[1]);
33    /// assert_eq!(3.0, a_slice[2]);
34    /// assert_eq!(4.0, a_slice[3]);
35    /// ```
36    pub fn as_slice(&self) -> &[T] {
37        unsafe { std::slice::from_raw_parts(self.as_ptr(), 4) }
38    }
39
40    ///
41    /// ```
42    /// use gfxmath_vec4::Vec4;
43    /// 
44    /// let mut a = Vec4::<f32>::new(1.0, 2.0, 3.0, 4.0);
45    /// 
46    /// {
47    ///     let a_slice = a.as_mut_slice();
48    /// 
49    ///     assert_eq!(1.0, a_slice[0]);
50    ///     assert_eq!(2.0, a_slice[1]);
51    ///     assert_eq!(3.0, a_slice[2]);
52    ///     assert_eq!(4.0, a_slice[3]);
53    /// 
54    ///     a_slice[2] = 108.0;
55    ///     assert_eq!(108.0, a_slice[2]); 
56    /// }
57    /// 
58    /// a.x = 4.5;
59    /// assert_eq!(4.5, a.x);
60    /// 
61    /// let a_slice = a.as_mut_slice();
62    /// 
63    /// assert_eq!(4.5, a_slice[0]);
64    /// assert_eq!(2.0, a_slice[1]);
65    /// assert_eq!(108.0, a_slice[2]);
66    /// assert_eq!(4.0, a_slice[3]);
67    /// ```
68    pub fn as_mut_slice(&mut self) -> &mut [T] {
69        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), 4) }
70    }
71}
72
73impl <T> Vec4<T> where T: Clone {
74    /// ```
75    /// use gfxmath_vec4::Vec4;
76    /// 
77    /// let v = Vec4::<f32>::all(2.5);
78    /// 
79    /// assert_eq!(2.5, v.x);
80    /// assert_eq!(2.5, v.y);
81    /// assert_eq!(2.5, v.z);
82    /// assert_eq!(2.5, v.w);
83    /// ```
84    pub fn all(val: T) -> Self {
85        Self::new(val.clone(), val.clone(), val.clone(), val.clone())
86    }
87}