1use std::fmt;
2use std::fmt::Debug;
3use std::ops::{Add, Sub, Mul, Div, Neg};
4use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign};
5use crate::vec::{Vec, Math, Interpolation};
6use crate::vec2::Vec2;
7use crate::vec4::Vec4;
8use crate::consts::{Zero, One, UnitX, UnitY, UnitZ};
9
10#[repr(C)]
11#[derive(Debug, Copy, Clone, Default, Hash, Eq, PartialEq)]
12pub struct Vec3<T>
13{
14 pub x: T,
15 pub y: T,
16 pub z: T,
17}
18
19impl<T> Neg for Vec3<T> where T:Neg<Output=T>
20{
21 type Output = Self;
22
23 fn neg(self) -> Self
24 {
25 Vec3
26 {
27 x: -self.x,
28 y: -self.y,
29 z: -self.z
30 }
31 }
32}
33
34impl<T> Add for Vec3<T> where T:Add<Output=T>
35{
36 type Output = Self;
37
38 fn add(self, other: Self) -> Self
39 {
40 Vec3
41 {
42 x: self.x + other.x,
43 y: self.y + other.y,
44 z: self.z + other.z
45 }
46 }
47}
48
49impl<T> Sub for Vec3<T> where T:Sub<Output=T>
50{
51 type Output = Self;
52
53 fn sub(self, other: Self) -> Self
54 {
55 Vec3
56 {
57 x: self.x - other.x,
58 y: self.y - other.y,
59 z: self.z - other.z
60 }
61 }
62}
63
64impl<T> Mul<T> for Vec3<T> where T:Mul<Output=T> + Copy
65{
66 type Output = Self;
67
68 fn mul(self, s: T) -> Self
69 {
70 Self
71 {
72 x:self.x * s,
73 y:self.y * s,
74 z:self.z * s
75 }
76 }
77}
78
79impl<T> Mul for Vec3<T> where T:Mul<Output=T>
80{
81 type Output = Self;
82
83 fn mul(self, other: Self) -> Self
84 {
85 Vec3
86 {
87 x: self.x * other.x,
88 y: self.y * other.y,
89 z: self.z * other.z
90 }
91 }
92}
93
94impl<T> Div<T> for Vec3<T> where T:Div<Output=T> + Copy
95{
96 type Output = Self;
97
98 fn div(self, s: T) -> Self
99 {
100 Self
101 {
102 x:self.x / s,
103 y:self.y / s,
104 z:self.z / s,
105 }
106 }
107}
108
109impl<T> Div for Vec3<T> where T:Div<Output=T>
110{
111 type Output = Self;
112
113 fn div(self, other: Self) -> Self
114 {
115 Vec3
116 {
117 x: self.x / other.x,
118 y: self.y / other.y,
119 z: self.z / other.z
120 }
121 }
122}
123
124impl<T> AddAssign for Vec3<T> where T: AddAssign<T>
125{
126 fn add_assign(&mut self, other: Self)
127 {
128 self.x += other.x;
129 self.y += other.y;
130 self.z += other.z;
131 }
132}
133
134impl<T> SubAssign for Vec3<T> where T: SubAssign<T>
135{
136 fn sub_assign(&mut self, other: Self)
137 {
138 self.x -= other.x;
139 self.y -= other.y;
140 self.z -= other.z;
141 }
142}
143
144impl<T> MulAssign<T> for Vec3<T> where T:MulAssign<T> + Copy
145{
146 fn mul_assign(&mut self, s: T)
147 {
148 self.x *= s;
149 self.y *= s;
150 self.z *= s;
151 }
152}
153
154impl<T> MulAssign for Vec3<T> where T: MulAssign<T>
155{
156 fn mul_assign(&mut self, other: Self)
157 {
158 self.x *= other.x;
159 self.y *= other.y;
160 self.z *= other.z;
161 }
162}
163
164impl<'a, T> MulAssign<&'a T> for Vec3<T> where T:MulAssign<T> + Copy
165{
166 fn mul_assign(&mut self, other: &'a T)
167 {
168 self.x *= *other;
169 self.y *= *other;
170 self.z *= *other;
171 }
172}
173
174impl<T> DivAssign<T> for Vec3<T> where T:DivAssign<T> + Copy
175{
176 fn div_assign(&mut self, s: T)
177 {
178 self.x /= s;
179 self.y /= s;
180 self.z /= s;
181 }
182}
183
184impl<T> DivAssign for Vec3<T> where T: DivAssign<T>
185{
186 fn div_assign(&mut self, other: Self)
187 {
188 self.x /= other.x;
189 self.y /= other.y;
190 self.z /= other.z;
191 }
192}
193
194impl<'a, T> DivAssign<&'a T> for Vec3<T> where T:DivAssign<T> + Copy
195{
196 fn div_assign(&mut self, s: &'a T)
197 {
198 self.x /= *s;
199 self.y /= *s;
200 self.z /= *s;
201 }
202}
203
204impl<T> Vec3<T> where T: Copy
205{
206 #[inline(always)]
208 pub fn new(x: T, y: T, z: T) -> Self { Self { x, y, z } }
209
210 #[inline(always)]
212 pub fn len() -> usize
213 {
214 return 3;
215 }
216
217 #[inline(always)]
218 pub fn to_tuple(&self) -> (T, T, T)
219 {
220 (self.x, self.y, self.z)
221 }
222
223 #[inline(always)]
224 pub fn xx(&self) -> Vec2<T> { Vec2::new(self.x, self.x) }
225 #[inline(always)]
226 pub fn xy(&self) -> Vec2<T> { Vec2::new(self.x, self.y) }
227 #[inline(always)]
228 pub fn xz(&self) -> Vec2<T> { Vec2::new(self.x, self.z) }
229 #[inline(always)]
230 pub fn yx(&self) -> Vec2<T> { Vec2::new(self.y, self.x) }
231 #[inline(always)]
232 pub fn yy(&self) -> Vec2<T> { Vec2::new(self.y, self.y) }
233 #[inline(always)]
234 pub fn yz(&self) -> Vec2<T> { Vec2::new(self.y, self.z) }
235 #[inline(always)]
236 pub fn zx(&self) -> Vec2<T> { Vec2::new(self.z, self.x) }
237 #[inline(always)]
238 pub fn zy(&self) -> Vec2<T> { Vec2::new(self.z, self.y) }
239 #[inline(always)]
240 pub fn zz(&self) -> Vec2<T> { Vec2::new(self.z, self.z) }
241 #[inline(always)]
242 pub fn xxx(&self) -> Self { Self::new(self.x, self.x, self.x) }
243 #[inline(always)]
244 pub fn xxy(&self) -> Self { Self::new(self.x, self.x, self.y) }
245 #[inline(always)]
246 pub fn xxz(&self) -> Self { Self::new(self.x, self.x, self.z) }
247 #[inline(always)]
248 pub fn xyx(&self) -> Self { Self::new(self.x, self.y, self.x) }
249 #[inline(always)]
250 pub fn xyy(&self) -> Self { Self::new(self.x, self.y, self.y) }
251 #[inline(always)]
252 pub fn xyz(&self) -> Self { Self::new(self.x, self.y, self.z) }
253 #[inline(always)]
254 pub fn xzx(&self) -> Self { Self::new(self.x, self.z, self.x) }
255 #[inline(always)]
256 pub fn xzy(&self) -> Self { Self::new(self.x, self.z, self.y) }
257 #[inline(always)]
258 pub fn xzz(&self) -> Self { Self::new(self.x, self.z, self.z) }
259 #[inline(always)]
260 pub fn yxx(&self) -> Self { Self::new(self.y, self.x, self.x) }
261 #[inline(always)]
262 pub fn yxy(&self) -> Self { Self::new(self.y, self.x, self.y) }
263 #[inline(always)]
264 pub fn yxz(&self) -> Self { Self::new(self.y, self.x, self.z) }
265 #[inline(always)]
266 pub fn yyx(&self) -> Self { Self::new(self.y, self.y, self.x) }
267 #[inline(always)]
268 pub fn yyy(&self) -> Self { Self::new(self.y, self.y, self.y) }
269 #[inline(always)]
270 pub fn yyz(&self) -> Self { Self::new(self.y, self.y, self.z) }
271 #[inline(always)]
272 pub fn yzx(&self) -> Self { Self::new(self.y, self.z, self.x) }
273 #[inline(always)]
274 pub fn yzy(&self) -> Self { Self::new(self.y, self.z, self.y) }
275 #[inline(always)]
276 pub fn yzz(&self) -> Self { Self::new(self.y, self.z, self.z) }
277 #[inline(always)]
278 pub fn zxx(&self) -> Self { Self::new(self.z, self.x, self.x) }
279 #[inline(always)]
280 pub fn zxy(&self) -> Self { Self::new(self.z, self.x, self.y) }
281 #[inline(always)]
282 pub fn zxz(&self) -> Self { Self::new(self.z, self.x, self.z) }
283 #[inline(always)]
284 pub fn zyx(&self) -> Self { Self::new(self.z, self.y, self.x) }
285 #[inline(always)]
286 pub fn zyy(&self) -> Self { Self::new(self.z, self.y, self.y) }
287 #[inline(always)]
288 pub fn zyz(&self) -> Self { Self::new(self.z, self.y, self.z) }
289 #[inline(always)]
290 pub fn zzx(&self) -> Self { Self::new(self.z, self.z, self.x) }
291 #[inline(always)]
292 pub fn zzy(&self) -> Self { Self::new(self.z, self.z, self.y) }
293 #[inline(always)]
294 pub fn zzz(&self) -> Self { Self::new(self.z, self.z, self.z) }
295 #[inline(always)]
296 pub fn xxxx(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.x, self.x) }
297 #[inline(always)]
298 pub fn xxxy(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.x, self.y) }
299 #[inline(always)]
300 pub fn xxxz(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.x, self.z) }
301 #[inline(always)]
302 pub fn xxyx(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.y, self.x) }
303 #[inline(always)]
304 pub fn xxyy(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.y, self.y) }
305 #[inline(always)]
306 pub fn xxyz(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.y, self.z) }
307 #[inline(always)]
308 pub fn xxzx(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.z, self.x) }
309 #[inline(always)]
310 pub fn xxzy(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.z, self.y) }
311 #[inline(always)]
312 pub fn xxzz(&self) -> Vec4<T> { Vec4::new(self.x, self.x, self.z, self.z) }
313 #[inline(always)]
314 pub fn xyxx(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.x, self.x) }
315 #[inline(always)]
316 pub fn xyxy(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.x, self.y) }
317 #[inline(always)]
318 pub fn xyxz(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.x, self.z) }
319 #[inline(always)]
320 pub fn xyyx(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.y, self.x) }
321 #[inline(always)]
322 pub fn xyyy(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.y, self.y) }
323 #[inline(always)]
324 pub fn xyyz(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.y, self.z) }
325 #[inline(always)]
326 pub fn xyzx(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.z, self.x) }
327 #[inline(always)]
328 pub fn xyzy(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.z, self.y) }
329 #[inline(always)]
330 pub fn xyzz(&self) -> Vec4<T> { Vec4::new(self.x, self.y, self.z, self.z) }
331 #[inline(always)]
332 pub fn xzxx(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.x, self.x) }
333 #[inline(always)]
334 pub fn xzxy(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.x, self.y) }
335 #[inline(always)]
336 pub fn xzxz(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.x, self.z) }
337 #[inline(always)]
338 pub fn xzyx(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.y, self.x) }
339 #[inline(always)]
340 pub fn xzyy(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.y, self.y) }
341 #[inline(always)]
342 pub fn xzyz(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.y, self.z) }
343 #[inline(always)]
344 pub fn xzzx(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.z, self.x) }
345 #[inline(always)]
346 pub fn xzzy(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.z, self.y) }
347 #[inline(always)]
348 pub fn xzzz(&self) -> Vec4<T> { Vec4::new(self.x, self.z, self.z, self.z) }
349 #[inline(always)]
350 pub fn yxxx(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.x, self.x) }
351 #[inline(always)]
352 pub fn yxxy(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.x, self.y) }
353 #[inline(always)]
354 pub fn yxxz(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.x, self.z) }
355 #[inline(always)]
356 pub fn yxyx(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.y, self.x) }
357 #[inline(always)]
358 pub fn yxyy(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.y, self.y) }
359 #[inline(always)]
360 pub fn yxyz(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.y, self.z) }
361 #[inline(always)]
362 pub fn yxzx(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.z, self.x) }
363 #[inline(always)]
364 pub fn yxzy(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.z, self.y) }
365 #[inline(always)]
366 pub fn yxzz(&self) -> Vec4<T> { Vec4::new(self.y, self.x, self.z, self.z) }
367 #[inline(always)]
368 pub fn yyxx(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.x, self.x) }
369 #[inline(always)]
370 pub fn yyxy(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.x, self.y) }
371 #[inline(always)]
372 pub fn yyxz(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.x, self.z) }
373 #[inline(always)]
374 pub fn yyyx(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.y, self.x) }
375 #[inline(always)]
376 pub fn yyyy(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.y, self.y) }
377 #[inline(always)]
378 pub fn yyyz(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.y, self.z) }
379 #[inline(always)]
380 pub fn yyzx(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.z, self.x) }
381 #[inline(always)]
382 pub fn yyzy(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.z, self.y) }
383 #[inline(always)]
384 pub fn yyzz(&self) -> Vec4<T> { Vec4::new(self.y, self.y, self.z, self.z) }
385 #[inline(always)]
386 pub fn yzxx(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.x, self.x) }
387 #[inline(always)]
388 pub fn yzxy(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.x, self.y) }
389 #[inline(always)]
390 pub fn yzxz(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.x, self.z) }
391 #[inline(always)]
392 pub fn yzyx(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.y, self.x) }
393 #[inline(always)]
394 pub fn yzyy(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.y, self.y) }
395 #[inline(always)]
396 pub fn yzyz(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.y, self.z) }
397 #[inline(always)]
398 pub fn yzzx(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.z, self.x) }
399 #[inline(always)]
400 pub fn yzzy(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.z, self.y) }
401 #[inline(always)]
402 pub fn yzzz(&self) -> Vec4<T> { Vec4::new(self.y, self.z, self.z, self.z) }
403 #[inline(always)]
404 pub fn zxxx(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.x, self.x) }
405 #[inline(always)]
406 pub fn zxxy(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.x, self.y) }
407 #[inline(always)]
408 pub fn zxxz(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.x, self.z) }
409 #[inline(always)]
410 pub fn zxyx(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.y, self.x) }
411 #[inline(always)]
412 pub fn zxyy(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.y, self.y) }
413 #[inline(always)]
414 pub fn zxyz(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.y, self.z) }
415 #[inline(always)]
416 pub fn zxzx(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.z, self.x) }
417 #[inline(always)]
418 pub fn zxzy(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.z, self.y) }
419 #[inline(always)]
420 pub fn zxzz(&self) -> Vec4<T> { Vec4::new(self.z, self.x, self.z, self.z) }
421 #[inline(always)]
422 pub fn zyxx(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.x, self.x) }
423 #[inline(always)]
424 pub fn zyxy(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.x, self.y) }
425 #[inline(always)]
426 pub fn zyxz(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.x, self.z) }
427 #[inline(always)]
428 pub fn zyyx(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.y, self.x) }
429 #[inline(always)]
430 pub fn zyyy(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.y, self.y) }
431 #[inline(always)]
432 pub fn zyyz(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.y, self.z) }
433 #[inline(always)]
434 pub fn zyzx(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.z, self.x) }
435 #[inline(always)]
436 pub fn zyzy(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.z, self.y) }
437 #[inline(always)]
438 pub fn zyzz(&self) -> Vec4<T> { Vec4::new(self.z, self.y, self.z, self.z) }
439 #[inline(always)]
440 pub fn zzxx(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.x, self.x) }
441 #[inline(always)]
442 pub fn zzxy(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.x, self.y) }
443 #[inline(always)]
444 pub fn zzxz(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.x, self.z) }
445 #[inline(always)]
446 pub fn zzyx(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.y, self.x) }
447 #[inline(always)]
448 pub fn zzyy(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.y, self.y) }
449 #[inline(always)]
450 pub fn zzyz(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.y, self.z) }
451 #[inline(always)]
452 pub fn zzzx(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.z, self.x) }
453 #[inline(always)]
454 pub fn zzzy(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.z, self.y) }
455 #[inline(always)]
456 pub fn zzzz(&self) -> Vec4<T> { Vec4::new(self.z, self.z, self.z, self.z) }
457}
458
459impl<T> Vec3<T> where T:Vec + Math
460{
461 #[inline]
462 pub fn dot(&self, b: Self) -> T
463 {
464 return self.x * b.x + self.y * b.y + self.z * b.z;
465 }
466
467 #[inline]
468 pub fn cross(&self, b: Self) -> Self
469 {
470 Vec3
471 {
472 x:self.y * b.z - self.z * b.y,
473 y:self.z * b.x - self.x * b.z,
474 z:self.x * b.y - self.y * b.x
475 }
476 }
477
478 #[inline]
479 pub fn length2(&self) -> T
480 {
481 return self.dot(*self);
482 }
483
484 #[inline]
485 pub fn length(&self) -> T
486 {
487 return self.length2().sqrt();
488 }
489
490 #[inline]
491 pub fn distance(&self, b: Self) -> T
492 {
493 return (*self - b).length();
494 }
495
496 #[inline]
497 pub fn normalize(&self) -> Self
498 {
499 let mag_sq = self.length2();
500 if mag_sq.gt(T::zero())
501 {
502 let inv_sqrt = T::one() / mag_sq.sqrt();
503 return *self * inv_sqrt;
504 }
505
506 return *self;
507 }
508}
509
510impl<T> Math for Vec3<T> where T:Copy + Math
511
512{ #[inline]
513 fn abs(self) -> Self
514 {
515 let mx = self.x.abs();
516 let my = self.y.abs();
517 let mz = self.z.abs();
518 Self { x: mx, y: my, z: mz }
519 }
520
521 #[inline]
522 fn recip(self) -> Self
523 {
524 let mx = self.x.recip();
525 let my = self.y.recip();
526 let mz = self.z.recip();
527 Self { x: mx, y: my, z: mz }
528 }
529
530 #[inline]
531 fn sqrt(self) -> Self
532 {
533 let mx = self.x.sqrt();
534 let my = self.y.sqrt();
535 let mz = self.z.sqrt();
536 Self { x: mx, y: my, z: mz }
537 }
538
539 #[inline]
540 fn rsqrt(self) -> Self
541 {
542 let mx = self.x.rsqrt();
543 let my = self.y.rsqrt();
544 let mz = self.z.rsqrt();
545 Self { x: mx, y: my, z: mz }
546 }
547
548 #[inline]
549 fn sin(self) -> Self
550 {
551 let mx = self.x.sin();
552 let my = self.y.sin();
553 let mz = self.z.sin();
554 Self { x: mx, y: my, z: mz }
555 }
556
557 #[inline]
558 fn cos(self) -> Self
559 {
560 let mx = self.x.cos();
561 let my = self.y.cos();
562 let mz = self.z.cos();
563 Self { x: mx, y: my, z: mz }
564 }
565
566 #[inline]
567 fn tan(self) -> Self
568 {
569 let mx = self.x.tan();
570 let my = self.y.tan();
571 let mz = self.z.tan();
572 Self { x: mx, y: my, z: mz }
573 }
574
575 #[inline]
576 fn sincos(self) -> (Self, Self)
577 {
578 let mx = self.x.sincos();
579 let my = self.y.sincos();
580 let mz = self.z.sincos();
581 (
582 Self { x: mx.0, y: my.0, z: mz.0 },
583 Self { x: mx.1, y: my.1, z: mz.1 }
584 )
585 }
586
587 #[inline]
588 fn acos(self) -> Self
589 {
590 let mx = self.x.acos();
591 let my = self.y.acos();
592 let mz = self.z.acos();
593 Self { x: mx, y: my, z: mz }
594 }
595
596 #[inline]
597 fn asin(self) -> Self
598 {
599 let mx = self.x.asin();
600 let my = self.y.asin();
601 let mz = self.z.asin();
602 Self { x: mx, y: my, z: mz }
603 }
604
605 #[inline]
606 fn atan(self) -> Self
607 {
608 let mx = self.x.atan();
609 let my = self.y.atan();
610 let mz = self.z.atan();
611 Self { x: mx, y: my, z: mz }
612 }
613
614 #[inline]
615 fn exp(self) -> Self
616 {
617 let mx = self.x.exp();
618 let my = self.y.exp();
619 let mz = self.z.exp();
620 Self { x: mx, y: my, z: mz }
621 }
622
623 #[inline]
624 fn exp2(self) -> Self
625 {
626 let mx = self.x.exp2();
627 let my = self.y.exp2();
628 let mz = self.z.exp2();
629 Self { x: mx, y: my, z: mz }
630 }
631
632 #[inline]
633 fn log(self, _rhs:Self) -> Self
634 {
635 let mx = self.x.log(_rhs.x);
636 let my = self.y.log(_rhs.y);
637 let mz = self.z.log(_rhs.z);
638 Self { x: mx, y: my, z: mz }
639 }
640
641 #[inline]
642 fn log2(self) -> Self
643 {
644 let mx = self.x.log2();
645 let my = self.y.log2();
646 let mz = self.z.log2();
647 Self { x: mx, y: my, z: mz }
648 }
649
650 #[inline]
651 fn log10(self) -> Self
652 {
653 let mx = self.x.log10();
654 let my = self.y.log10();
655 let mz = self.z.log10();
656 Self { x: mx, y: my, z: mz }
657 }
658
659 #[inline]
660 fn to_radians(self) -> Self
661 {
662 let mx = self.x.to_radians();
663 let my = self.y.to_radians();
664 let mz = self.z.to_radians();
665 Self { x: mx, y: my, z: mz }
666 }
667
668 #[inline]
669 fn to_degrees(self) -> Self
670 {
671 let mx = self.x.to_degrees();
672 let my = self.y.to_degrees();
673 let mz = self.z.to_degrees();
674 Self { x: mx, y: my, z: mz }
675 }
676
677 #[inline]
678 fn min(self, _rhs: Self) -> Self
679 {
680 let mx = self.x.min(_rhs.x);
681 let my = self.y.min(_rhs.y);
682 let mz = self.z.min(_rhs.z);
683 Self { x: mx, y: my, z: mz }
684 }
685
686 #[inline]
687 fn max(self, _rhs: Self) -> Self
688 {
689 let mx = self.x.max(_rhs.x);
690 let my = self.y.max(_rhs.y);
691 let mz = self.z.max(_rhs.z);
692 Self { x: mx, y: my, z: mz }
693 }
694
695 #[inline]
696 fn saturate(self) -> Self
697 {
698 let mx = self.x.saturate();
699 let my = self.y.saturate();
700 let mz = self.z.saturate();
701 Self { x: mx, y: my, z: mz }
702 }
703
704 #[inline]
705 fn snorm2unorm(self) -> Self
706 {
707 let mx = self.x.snorm2unorm();
708 let my = self.y.snorm2unorm();
709 let mz = self.z.snorm2unorm();
710 Self { x: mx, y: my, z: mz }
711 }
712
713 #[inline]
714 fn unorm2snorm(self) -> Self
715 {
716 let mx = self.x.unorm2snorm();
717 let my = self.y.unorm2snorm();
718 let mz = self.z.unorm2snorm();
719 Self { x: mx, y: my, z: mz }
720 }
721
722 #[inline]
723 fn clamp(self, minval: Self, maxval: Self) -> Self
724 {
725 let mx = self.x.clamp(minval.x, maxval.x);
726 let my = self.y.clamp(minval.y, maxval.y);
727 let mz = self.z.clamp(minval.z, maxval.z);
728 Self { x: mx, y: my, z: mz }
729 }
730}
731
732impl<T> Interpolation<T> for Vec3<T> where T: Copy + One + Mul<Output=T> + Add<Output=T> + Sub<Output=T>
733{
734 #[inline(always)]
735 fn lerp(self, b: Self, t: T) -> Self
736 {
737 return self*(T::one() - t) + b*t;
738 }
739}
740
741impl<T> Zero for Vec3<T> where T:Zero
742{
743 #[inline(always)]
744 fn zero() -> Self
745 {
746 Vec3
747 {
748 x: T::zero(), y: T::zero(), z: T::zero()
749 }
750 }
751}
752
753impl<T> One for Vec3<T> where T:One
754{
755 #[inline(always)]
756 fn one() -> Self
757 {
758 Vec3
759 {
760 x: T::one(), y: T::one(), z: T::one()
761 }
762 }
763}
764
765impl<T> UnitX for Vec3<T> where T:One + Zero
766{
767 #[inline(always)]
768 fn unit_x() -> Self
769 {
770 Self
771 {
772 x: T::one(), y: T::zero(), z: T::zero()
773 }
774 }
775}
776
777impl<T> UnitY for Vec3<T> where T:One + Zero
778{
779 #[inline(always)]
780 fn unit_y() -> Self
781 {
782 Self
783 {
784 x: T::zero(), y: T::one(), z: T::zero()
785 }
786 }
787}
788
789impl<T> UnitZ for Vec3<T> where T:One + Zero
790{
791 #[inline(always)]
792 fn unit_z() -> Self
793 {
794 Self
795 {
796 x: T::zero(), y: T::one(), z: T::zero()
797 }
798 }
799}
800
801impl<T> fmt::Display for Vec3<T> where T:Debug
802{
803 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
804 {
805 write!(f, "({:?}, {:?}, {:?})", self.x, self.y, self.z)
806 }
807}
808
809impl<T> fmt::Binary for Vec3<T> where T:Vec + Math
810{
811 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
812 {
813 let len = self.length();
814 let decimals = f.precision().unwrap_or(3);
815 let string = format!("{:.*?}", decimals, len);
816 f.pad_integral(true, "", &string)
817 }
818}
819
820impl<T> From<[T;3]> for Vec3<T> where T:Copy
821{
822 fn from(v:[T;3]) -> Self
823 {
824 Self
825 {
826 x:v[0],
827 y:v[1],
828 z:v[2],
829 }
830 }
831}
832
833impl<T> From<(T,T,T)> for Vec3<T> where T:Copy
834{
835 fn from(v:(T,T,T)) -> Self
836 {
837 Self
838 {
839 x:v.0,
840 y:v.1,
841 z:v.2,
842 }
843 }
844}
845
846impl<T> AsRef<Vec3<T>> for Vec3<T>
847{
848 fn as_ref(&self) -> &Vec3<T>
849 {
850 self
851 }
852}
853
854impl<T> AsMut<Vec3<T>> for Vec3<T>
855{
856 fn as_mut(&mut self) -> &mut Vec3<T>
857 {
858 self
859 }
860}