gfxmath-vec4 0.1.1

A simple 3D math library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#[repr(C)]
#[derive(Debug, Clone, PartialEq)]
pub struct Vec4<T> {
    pub x: T,
    pub y: T,
    pub z: T,
    pub w: T
}

impl <T> Vec4 <T> {
    pub fn new(x: T, y: T, z: T, w: T) -> Self {
        Self { x, y, z, w }
    }

    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }

    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }

    ///
    /// ```
    /// use gfxmath_vec4::Vec4;
    /// 
    /// let a = Vec4::<f32>::new(1.0, 2.0, 3.0, 4.0);
    /// 
    /// let a_slice = a.as_slice();
    /// 
    /// assert_eq!(1.0, a_slice[0]);
    /// assert_eq!(2.0, a_slice[1]);
    /// assert_eq!(3.0, a_slice[2]);
    /// assert_eq!(4.0, a_slice[3]);
    /// ```
    pub fn as_slice(&self) -> &[T] {
        unsafe { std::slice::from_raw_parts(self.as_ptr(), 4) }
    }

    ///
    /// ```
    /// use gfxmath_vec4::Vec4;
    /// 
    /// let mut a = Vec4::<f32>::new(1.0, 2.0, 3.0, 4.0);
    /// 
    /// {
    ///     let a_slice = a.as_mut_slice();
    /// 
    ///     assert_eq!(1.0, a_slice[0]);
    ///     assert_eq!(2.0, a_slice[1]);
    ///     assert_eq!(3.0, a_slice[2]);
    ///     assert_eq!(4.0, a_slice[3]);
    /// 
    ///     a_slice[2] = 108.0;
    ///     assert_eq!(108.0, a_slice[2]); 
    /// }
    /// 
    /// a.x = 4.5;
    /// assert_eq!(4.5, a.x);
    /// 
    /// let a_slice = a.as_mut_slice();
    /// 
    /// assert_eq!(4.5, a_slice[0]);
    /// assert_eq!(2.0, a_slice[1]);
    /// assert_eq!(108.0, a_slice[2]);
    /// assert_eq!(4.0, a_slice[3]);
    /// ```
    pub fn as_mut_slice(&mut self) -> &mut [T] {
        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), 4) }
    }
}

impl <T> Vec4<T> where T: Clone {
    /// ```
    /// use gfxmath_vec4::Vec4;
    /// 
    /// let v = Vec4::<f32>::all(2.5);
    /// 
    /// assert_eq!(2.5, v.x);
    /// assert_eq!(2.5, v.y);
    /// assert_eq!(2.5, v.z);
    /// assert_eq!(2.5, v.w);
    /// ```
    pub fn all(val: T) -> Self {
        Self::new(val.clone(), val.clone(), val.clone(), val.clone())
    }
}