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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::Vec4D;

impl Vec4D {
    /// The zero vector, i.e. the additive identity.
    pub const ZERO: Vec4D = Vec4D([0.0; 4]);

    /// Create a new vector.
    #[inline]
    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
        Self([x, y, z, w])
    }

    /// The x-coordinate, i.e. index 0.
    #[inline]
    pub fn x(&self) -> f32 {
        self.0[0]
    }

    /// The y-coordinate, i.e. index 1.
    #[inline]
    pub fn y(&self) -> f32 {
        self.0[1]
    }

    /// The z-coordinate, i.e. index 2.
    #[inline]
    pub fn z(&self) -> f32 {
        self.0[2]
    }

    /// The w-coordinate, i.e. index 3.
    #[inline]
    pub fn w(&self) -> f32 {
        self.0[3]
    }
}

impl From<(f32, f32, f32, f32)> for Vec4D {
    #[inline]
    fn from((x, y, z, w): (f32, f32, f32, f32)) -> Self {
        Self::new(x, y, z, w)
    }
}

// NOTE: All these by-ref impls make the lives of end-users much easier when juggling around with
// slices, because Rust cannot keep track of the inherent `Copy` capability of it all across all the
// layers of `Into`/`IntoIterator`.

impl<'a> From<&'a Vec4D> for Vec4D {
    fn from(v: &'a Vec4D) -> Self {
        Self(v.0)
    }
}

impl<'a> From<&'a (f32, f32, f32, f32)> for Vec4D {
    #[inline]
    fn from((x, y, z, w): &'a (f32, f32, f32, f32)) -> Self {
        Self::new(*x, *y, *z, *w)
    }
}

impl<'a> From<&'a [f32; 4]> for Vec4D {
    #[inline]
    fn from(v: &'a [f32; 4]) -> Self {
        Self(*v)
    }
}

impl<Idx> std::ops::Index<Idx> for Vec4D
where
    Idx: std::slice::SliceIndex<[f32]>,
{
    type Output = Idx::Output;

    #[inline]
    fn index(&self, index: Idx) -> &Self::Output {
        &self.0[index]
    }
}

#[cfg(feature = "glam")]
impl From<Vec4D> for glam::Vec4 {
    #[inline]
    fn from(v: Vec4D) -> Self {
        Self::from_slice(&v.0)
    }
}

#[cfg(feature = "glam")]
impl From<glam::Vec4> for Vec4D {
    #[inline]
    fn from(v: glam::Vec4) -> Self {
        Self(v.to_array())
    }
}

#[cfg(feature = "mint")]
impl From<Vec4D> for mint::Vector4<f32> {
    #[inline]
    fn from(v: Vec4D) -> Self {
        Self {
            x: v[0],
            y: v[1],
            z: v[2],
            w: v[3],
        }
    }
}

#[cfg(feature = "mint")]
impl From<mint::Vector4<f32>> for Vec4D {
    #[inline]
    fn from(v: mint::Vector4<f32>) -> Self {
        Self([v.x, v.y, v.z, v.w])
    }
}

impl std::fmt::Display for Vec4D {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "[{:.prec$}, {:.prec$}, {:.prec$}, {:.prec$}]",
            self.x(),
            self.y(),
            self.z(),
            self.w(),
            prec = crate::DISPLAY_PRECISION,
        )
    }
}