gfxmath-vec3 0.1.4

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

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

impl <T> Vec3 <T> {
    /// ```
    /// use gfxmath_vec3::Vec3;
    /// 
    /// let v = Vec3::<f32>::new(2.5, 0.0, -19.5);
    /// 
    /// assert_eq!(2.5, v.x);
    /// assert_eq!(0.0, v.y);
    /// assert_eq!(-19.5, v.z);
    /// ```
    pub fn new(x: T, y: T, z: T) -> Self {
        return Self { x, y, z }
    }

    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_vec3::Vec3;
    /// 
    /// let a = Vec3::<f32>::new(1.0, 2.0, 3.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]);
    /// ```
    pub fn as_slice(&self) -> &[T] {
        unsafe { std::slice::from_raw_parts(self.as_ptr(), 3) }
    }

    ///
    /// ```
    /// use gfxmath_vec3::Vec3;
    /// 
    /// let mut a = Vec3::<f32>::new(1.0, 2.0, 3.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]);
    /// 
    ///     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]);
    /// ```
    pub fn as_mut_slice(&mut self) -> &mut [T] {
        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), 3) }
    }
}

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

/// ```
/// use gfxmath_vec3::{Vec3, vec3};
/// 
/// let v = vec3!(1.0, 2.0, 3.0);
/// 
/// assert_eq!(1.0, v.x);
/// assert_eq!(2.0, v.y);
/// assert_eq!(3.0, v.z);
/// ```
#[macro_export]
macro_rules! vec3 {
    ($x: expr, $y: expr, $z: expr) => {
        {
            Vec3::new($x, $y, $z)
        }
    }
}