1use super::*;
2
3impl Vector3 {
4 pub fn new(X: f32, Y: f32, Z: f32) -> Self {
5 Self { X, Y, Z }
6 }
7 pub fn zero() -> Self {
8 Self {
9 X: 0f32,
10 Y: 0f32,
11 Z: 0f32,
12 }
13 }
14 pub fn one() -> Self {
15 Self {
16 X: 1f32,
17 Y: 1f32,
18 Z: 1f32,
19 }
20 }
21 pub fn unit_x() -> Self {
22 Self {
23 X: 1.0,
24 Y: 0.0,
25 Z: 0.0,
26 }
27 }
28 pub fn unit_y() -> Self {
29 Self {
30 X: 0.0,
31 Y: 1.0,
32 Z: 0.0,
33 }
34 }
35 pub fn unit_z() -> Self {
36 Self {
37 X: 0.0,
38 Y: 0.0,
39 Z: 1.0,
40 }
41 }
42 pub fn dot(&self, rhs: &Self) -> f32 {
43 self.X * rhs.X + self.Y * rhs.Y + self.Z * rhs.Z
44 }
45 pub fn length_squared(&self) -> f32 {
46 self.dot(self)
47 }
48 #[cfg(feature = "std")]
49 pub fn length(&self) -> f32 {
50 self.length_squared().sqrt()
51 }
52 #[cfg(feature = "std")]
53 pub fn distance(&self, value: &Self) -> f32 {
54 (self - value).length()
55 }
56 pub fn distance_squared(&self, value: &Self) -> f32 {
57 (self - value).length_squared()
58 }
59 #[cfg(feature = "std")]
60 pub fn normalize(&self) -> Self {
61 self / self.length()
62 }
63
64 fn impl_add(&self, rhs: &Self) -> Self {
65 Self {
66 X: self.X + rhs.X,
67 Y: self.Y + rhs.Y,
68 Z: self.Z + rhs.Z,
69 }
70 }
71 fn impl_sub(&self, rhs: &Self) -> Self {
72 Self {
73 X: self.X - rhs.X,
74 Y: self.Y - rhs.Y,
75 Z: self.Z - rhs.Z,
76 }
77 }
78 fn impl_div(&self, rhs: &Self) -> Self {
79 Self {
80 X: self.X / rhs.X,
81 Y: self.Y / rhs.Y,
82 Z: self.Z / rhs.Z,
83 }
84 }
85 fn impl_div_f32(&self, rhs: f32) -> Self {
86 Self {
87 X: self.X / rhs,
88 Y: self.Y / rhs,
89 Z: self.Z / rhs,
90 }
91 }
92 fn impl_mul(&self, rhs: &Self) -> Self {
93 Self {
94 X: self.X * rhs.X,
95 Y: self.Y * rhs.Y,
96 Z: self.Z * rhs.Z,
97 }
98 }
99 fn impl_mul_f32(&self, rhs: f32) -> Self {
100 Self {
101 X: self.X * rhs,
102 Y: self.Y * rhs,
103 Z: self.Z * rhs,
104 }
105 }
106}
107
108impl core::ops::Add<Vector3> for Vector3 {
109 type Output = Vector3;
110 fn add(self, rhs: Vector3) -> Vector3 {
111 self.impl_add(&rhs)
112 }
113}
114impl core::ops::Add<&Vector3> for Vector3 {
115 type Output = Vector3;
116 fn add(self, rhs: &Vector3) -> Vector3 {
117 self.impl_add(rhs)
118 }
119}
120impl core::ops::Add<Vector3> for &Vector3 {
121 type Output = Vector3;
122 fn add(self, rhs: Vector3) -> Vector3 {
123 self.impl_add(&rhs)
124 }
125}
126impl core::ops::Add<&Vector3> for &Vector3 {
127 type Output = Vector3;
128 fn add(self, rhs: &Vector3) -> Vector3 {
129 self.impl_add(rhs)
130 }
131}
132impl core::ops::Sub<Vector3> for Vector3 {
133 type Output = Vector3;
134 fn sub(self, rhs: Vector3) -> Vector3 {
135 self.impl_sub(&rhs)
136 }
137}
138impl core::ops::Sub<&Vector3> for Vector3 {
139 type Output = Vector3;
140 fn sub(self, rhs: &Vector3) -> Vector3 {
141 self.impl_sub(rhs)
142 }
143}
144impl core::ops::Sub<Vector3> for &Vector3 {
145 type Output = Vector3;
146 fn sub(self, rhs: Vector3) -> Vector3 {
147 self.impl_sub(&rhs)
148 }
149}
150impl core::ops::Sub<&Vector3> for &Vector3 {
151 type Output = Vector3;
152 fn sub(self, rhs: &Vector3) -> Vector3 {
153 self.impl_sub(rhs)
154 }
155}
156impl core::ops::Div<Vector3> for Vector3 {
157 type Output = Vector3;
158 fn div(self, rhs: Vector3) -> Vector3 {
159 self.impl_div(&rhs)
160 }
161}
162impl core::ops::Div<&Vector3> for Vector3 {
163 type Output = Vector3;
164 fn div(self, rhs: &Vector3) -> Vector3 {
165 self.impl_div(rhs)
166 }
167}
168impl core::ops::Div<Vector3> for &Vector3 {
169 type Output = Vector3;
170 fn div(self, rhs: Vector3) -> Vector3 {
171 self.impl_div(&rhs)
172 }
173}
174impl core::ops::Div<&Vector3> for &Vector3 {
175 type Output = Vector3;
176 fn div(self, rhs: &Vector3) -> Vector3 {
177 self.impl_div(rhs)
178 }
179}
180impl core::ops::Div<f32> for Vector3 {
181 type Output = Vector3;
182 fn div(self, rhs: f32) -> Vector3 {
183 self.impl_div_f32(rhs)
184 }
185}
186impl core::ops::Div<f32> for &Vector3 {
187 type Output = Vector3;
188 fn div(self, rhs: f32) -> Vector3 {
189 self.impl_div_f32(rhs)
190 }
191}
192impl core::ops::Mul<Vector3> for Vector3 {
193 type Output = Vector3;
194 fn mul(self, rhs: Vector3) -> Vector3 {
195 self.impl_mul(&rhs)
196 }
197}
198impl core::ops::Mul<&Vector3> for Vector3 {
199 type Output = Vector3;
200 fn mul(self, rhs: &Vector3) -> Vector3 {
201 self.impl_mul(rhs)
202 }
203}
204impl core::ops::Mul<Vector3> for &Vector3 {
205 type Output = Vector3;
206 fn mul(self, rhs: Vector3) -> Vector3 {
207 self.impl_mul(&rhs)
208 }
209}
210impl core::ops::Mul<&Vector3> for &Vector3 {
211 type Output = Vector3;
212 fn mul(self, rhs: &Vector3) -> Vector3 {
213 self.impl_mul(rhs)
214 }
215}
216impl core::ops::Mul<f32> for Vector3 {
217 type Output = Vector3;
218 fn mul(self, rhs: f32) -> Vector3 {
219 self.impl_mul_f32(rhs)
220 }
221}
222impl core::ops::Mul<f32> for &Vector3 {
223 type Output = Vector3;
224 fn mul(self, rhs: f32) -> Vector3 {
225 self.impl_mul_f32(rhs)
226 }
227}
228