GCC Code Coverage Report

Directory: ./
File: src/tide/dependencies/glm/glm/detail/type_vec3.inl
Date: 2023-04-27 00:55:30
Exec Total Coverage
Lines: 0 14 0.0%
Functions: 0 4 0.0%
Branches: 0 7 0.0%
Line Branch Exec Source
1 /// @ref core
2
3 #include "compute_vector_relational.hpp"
4
5 namespace glm
6 {
7 // -- Implicit basic constructors --
8
9 # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
10 template<typename T, qualifier Q>
11 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec()
12 # if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
13 : x(0), y(0), z(0)
14 # endif
15 {}
16
17 template<typename T, qualifier Q>
18 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, Q> const& v)
19 : x(v.x), y(v.y), z(v.z)
20 {}
21 # endif
22
23 template<typename T, qualifier Q>
24 template<qualifier P>
25 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, P> const& v)
26 : x(v.x), y(v.y), z(v.z)
27 {}
28
29 // -- Explicit basic constructors --
30
31 template<typename T, qualifier Q>
32 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T scalar)
33 : x(scalar), y(scalar), z(scalar)
34 {}
35
36 template <typename T, qualifier Q>
37 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T _x, T _y, T _z)
38 ✗ : x(_x), y(_y), z(_z)
39 ✗ {}
40
41 // -- Conversion scalar constructors --
42
43 template<typename T, qualifier Q>
44 template<typename U, qualifier P>
45 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, U, P> const& v)
46 : x(static_cast<T>(v.x))
47 , y(static_cast<T>(v.x))
48 , z(static_cast<T>(v.x))
49 {}
50
51 template<typename T, qualifier Q>
52 template<typename X, typename Y, typename Z>
53 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, Z _z)
54 ✗ : x(static_cast<T>(_x))
55 ✗ , y(static_cast<T>(_y))
56 ✗ , z(static_cast<T>(_z))
57 ✗ {}
58
59 template<typename T, qualifier Q>
60 template<typename X, typename Y, typename Z>
61 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z)
62 : x(static_cast<T>(_x.x))
63 , y(static_cast<T>(_y))
64 , z(static_cast<T>(_z))
65 {}
66
67 template<typename T, qualifier Q>
68 template<typename X, typename Y, typename Z>
69 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z)
70 : x(static_cast<T>(_x))
71 , y(static_cast<T>(_y.x))
72 , z(static_cast<T>(_z))
73 {}
74
75 template<typename T, qualifier Q>
76 template<typename X, typename Y, typename Z>
77 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z)
78 : x(static_cast<T>(_x.x))
79 , y(static_cast<T>(_y.x))
80 , z(static_cast<T>(_z))
81 {}
82
83 template<typename T, qualifier Q>
84 template<typename X, typename Y, typename Z>
85 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z)
86 : x(static_cast<T>(_x))
87 , y(static_cast<T>(_y))
88 , z(static_cast<T>(_z.x))
89 {}
90
91 template<typename T, qualifier Q>
92 template<typename X, typename Y, typename Z>
93 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z)
94 : x(static_cast<T>(_x.x))
95 , y(static_cast<T>(_y))
96 , z(static_cast<T>(_z.x))
97 {}
98
99 template<typename T, qualifier Q>
100 template<typename X, typename Y, typename Z>
101 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
102 : x(static_cast<T>(_x))
103 , y(static_cast<T>(_y.x))
104 , z(static_cast<T>(_z.x))
105 {}
106
107 template<typename T, qualifier Q>
108 template<typename X, typename Y, typename Z>
109 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
110 : x(static_cast<T>(_x.x))
111 , y(static_cast<T>(_y.x))
112 , z(static_cast<T>(_z.x))
113 {}
114
115 // -- Conversion vector constructors --
116
117 template<typename T, qualifier Q>
118 template<typename A, typename B, qualifier P>
119 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, B _z)
120 : x(static_cast<T>(_xy.x))
121 , y(static_cast<T>(_xy.y))
122 , z(static_cast<T>(_z))
123 {}
124
125 template<typename T, qualifier Q>
126 template<typename A, typename B, qualifier P>
127 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z)
128 : x(static_cast<T>(_xy.x))
129 , y(static_cast<T>(_xy.y))
130 , z(static_cast<T>(_z.x))
131 {}
132
133 template<typename T, qualifier Q>
134 template<typename A, typename B, qualifier P>
135 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(A _x, vec<2, B, P> const& _yz)
136 : x(static_cast<T>(_x))
137 , y(static_cast<T>(_yz.x))
138 , z(static_cast<T>(_yz.y))
139 {}
140
141 template<typename T, qualifier Q>
142 template<typename A, typename B, qualifier P>
143 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz)
144 : x(static_cast<T>(_x.x))
145 , y(static_cast<T>(_yz.x))
146 , z(static_cast<T>(_yz.y))
147 {}
148
149 template<typename T, qualifier Q>
150 template<typename U, qualifier P>
151 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, U, P> const& v)
152 : x(static_cast<T>(v.x))
153 , y(static_cast<T>(v.y))
154 , z(static_cast<T>(v.z))
155 {}
156
157 template<typename T, qualifier Q>
158 template<typename U, qualifier P>
159 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<4, U, P> const& v)
160 : x(static_cast<T>(v.x))
161 , y(static_cast<T>(v.y))
162 , z(static_cast<T>(v.z))
163 {}
164
165 // -- Component accesses --
166
167 template<typename T, qualifier Q>
168 GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i)
169 {
170 assert(i >= 0 && i < this->length());
171 switch(i)
172 {
173 default:
174 case 0:
175 return x;
176 case 1:
177 return y;
178 case 2:
179 return z;
180 }
181 }
182
183 template<typename T, qualifier Q>
184 GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) const
185 {
186 ✗ assert(i >= 0 && i < this->length());
187 ✗ switch(i)
188 {
189 ✗ default:
190 case 0:
191 ✗ return x;
192 ✗ case 1:
193 ✗ return y;
194 ✗ case 2:
195 ✗ return z;
196 }
197 }
198
199 // -- Unary arithmetic operators --
200
201 # if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
202 template<typename T, qualifier Q>
203 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v)
204 {
205 this->x = v.x;
206 this->y = v.y;
207 this->z = v.z;
208 return *this;
209 }
210 # endif
211
212 template<typename T, qualifier Q>
213 template<typename U>
214 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v)
215 {
216 this->x = static_cast<T>(v.x);
217 this->y = static_cast<T>(v.y);
218 this->z = static_cast<T>(v.z);
219 return *this;
220 }
221
222 template<typename T, qualifier Q>
223 template<typename U>
224 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(U scalar)
225 {
226 this->x += static_cast<T>(scalar);
227 this->y += static_cast<T>(scalar);
228 this->z += static_cast<T>(scalar);
229 return *this;
230 }
231
232 template<typename T, qualifier Q>
233 template<typename U>
234 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<1, U, Q> const& v)
235 {
236 this->x += static_cast<T>(v.x);
237 this->y += static_cast<T>(v.x);
238 this->z += static_cast<T>(v.x);
239 return *this;
240 }
241
242 template<typename T, qualifier Q>
243 template<typename U>
244 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<3, U, Q> const& v)
245 {
246 this->x += static_cast<T>(v.x);
247 this->y += static_cast<T>(v.y);
248 this->z += static_cast<T>(v.z);
249 return *this;
250 }
251
252 template<typename T, qualifier Q>
253 template<typename U>
254 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(U scalar)
255 {
256 this->x -= static_cast<T>(scalar);
257 this->y -= static_cast<T>(scalar);
258 this->z -= static_cast<T>(scalar);
259 return *this;
260 }
261
262 template<typename T, qualifier Q>
263 template<typename U>
264 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<1, U, Q> const& v)
265 {
266 this->x -= static_cast<T>(v.x);
267 this->y -= static_cast<T>(v.x);
268 this->z -= static_cast<T>(v.x);
269 return *this;
270 }
271
272 template<typename T, qualifier Q>
273 template<typename U>
274 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<3, U, Q> const& v)
275 {
276 this->x -= static_cast<T>(v.x);
277 this->y -= static_cast<T>(v.y);
278 this->z -= static_cast<T>(v.z);
279 return *this;
280 }
281
282 template<typename T, qualifier Q>
283 template<typename U>
284 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(U scalar)
285 {
286 this->x *= static_cast<T>(scalar);
287 this->y *= static_cast<T>(scalar);
288 this->z *= static_cast<T>(scalar);
289 return *this;
290 }
291
292 template<typename T, qualifier Q>
293 template<typename U>
294 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<1, U, Q> const& v)
295 {
296 this->x *= static_cast<T>(v.x);
297 this->y *= static_cast<T>(v.x);
298 this->z *= static_cast<T>(v.x);
299 return *this;
300 }
301
302 template<typename T, qualifier Q>
303 template<typename U>
304 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<3, U, Q> const& v)
305 {
306 this->x *= static_cast<T>(v.x);
307 this->y *= static_cast<T>(v.y);
308 this->z *= static_cast<T>(v.z);
309 return *this;
310 }
311
312 template<typename T, qualifier Q>
313 template<typename U>
314 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(U v)
315 {
316 this->x /= static_cast<T>(v);
317 this->y /= static_cast<T>(v);
318 this->z /= static_cast<T>(v);
319 return *this;
320 }
321
322 template<typename T, qualifier Q>
323 template<typename U>
324 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<1, U, Q> const& v)
325 {
326 this->x /= static_cast<T>(v.x);
327 this->y /= static_cast<T>(v.x);
328 this->z /= static_cast<T>(v.x);
329 return *this;
330 }
331
332 template<typename T, qualifier Q>
333 template<typename U>
334 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<3, U, Q> const& v)
335 {
336 this->x /= static_cast<T>(v.x);
337 this->y /= static_cast<T>(v.y);
338 this->z /= static_cast<T>(v.z);
339 return *this;
340 }
341
342 // -- Increment and decrement operators --
343
344 template<typename T, qualifier Q>
345 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator++()
346 {
347 ++this->x;
348 ++this->y;
349 ++this->z;
350 return *this;
351 }
352
353 template<typename T, qualifier Q>
354 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator--()
355 {
356 --this->x;
357 --this->y;
358 --this->z;
359 return *this;
360 }
361
362 template<typename T, qualifier Q>
363 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator++(int)
364 {
365 vec<3, T, Q> Result(*this);
366 ++*this;
367 return Result;
368 }
369
370 template<typename T, qualifier Q>
371 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator--(int)
372 {
373 vec<3, T, Q> Result(*this);
374 --*this;
375 return Result;
376 }
377
378 // -- Unary bit operators --
379
380 template<typename T, qualifier Q>
381 template<typename U>
382 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(U scalar)
383 {
384 this->x %= scalar;
385 this->y %= scalar;
386 this->z %= scalar;
387 return *this;
388 }
389
390 template<typename T, qualifier Q>
391 template<typename U>
392 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<1, U, Q> const& v)
393 {
394 this->x %= v.x;
395 this->y %= v.x;
396 this->z %= v.x;
397 return *this;
398 }
399
400 template<typename T, qualifier Q>
401 template<typename U>
402 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<3, U, Q> const& v)
403 {
404 this->x %= v.x;
405 this->y %= v.y;
406 this->z %= v.z;
407 return *this;
408 }
409
410 template<typename T, qualifier Q>
411 template<typename U>
412 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(U scalar)
413 {
414 this->x &= scalar;
415 this->y &= scalar;
416 this->z &= scalar;
417 return *this;
418 }
419
420 template<typename T, qualifier Q>
421 template<typename U>
422 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<1, U, Q> const& v)
423 {
424 this->x &= v.x;
425 this->y &= v.x;
426 this->z &= v.x;
427 return *this;
428 }
429
430 template<typename T, qualifier Q>
431 template<typename U>
432 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<3, U, Q> const& v)
433 {
434 this->x &= v.x;
435 this->y &= v.y;
436 this->z &= v.z;
437 return *this;
438 }
439
440 template<typename T, qualifier Q>
441 template<typename U>
442 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(U scalar)
443 {
444 this->x |= scalar;
445 this->y |= scalar;
446 this->z |= scalar;
447 return *this;
448 }
449
450 template<typename T, qualifier Q>
451 template<typename U>
452 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<1, U, Q> const& v)
453 {
454 this->x |= v.x;
455 this->y |= v.x;
456 this->z |= v.x;
457 return *this;
458 }
459
460 template<typename T, qualifier Q>
461 template<typename U>
462 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<3, U, Q> const& v)
463 {
464 this->x |= v.x;
465 this->y |= v.y;
466 this->z |= v.z;
467 return *this;
468 }
469
470 template<typename T, qualifier Q>
471 template<typename U>
472 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(U scalar)
473 {
474 this->x ^= scalar;
475 this->y ^= scalar;
476 this->z ^= scalar;
477 return *this;
478 }
479
480 template<typename T, qualifier Q>
481 template<typename U>
482 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<1, U, Q> const& v)
483 {
484 this->x ^= v.x;
485 this->y ^= v.x;
486 this->z ^= v.x;
487 return *this;
488 }
489
490 template<typename T, qualifier Q>
491 template<typename U>
492 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<3, U, Q> const& v)
493 {
494 this->x ^= v.x;
495 this->y ^= v.y;
496 this->z ^= v.z;
497 return *this;
498 }
499
500 template<typename T, qualifier Q>
501 template<typename U>
502 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(U scalar)
503 {
504 this->x <<= scalar;
505 this->y <<= scalar;
506 this->z <<= scalar;
507 return *this;
508 }
509
510 template<typename T, qualifier Q>
511 template<typename U>
512 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<1, U, Q> const& v)
513 {
514 this->x <<= static_cast<T>(v.x);
515 this->y <<= static_cast<T>(v.x);
516 this->z <<= static_cast<T>(v.x);
517 return *this;
518 }
519
520 template<typename T, qualifier Q>
521 template<typename U>
522 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<3, U, Q> const& v)
523 {
524 this->x <<= static_cast<T>(v.x);
525 this->y <<= static_cast<T>(v.y);
526 this->z <<= static_cast<T>(v.z);
527 return *this;
528 }
529
530 template<typename T, qualifier Q>
531 template<typename U>
532 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(U scalar)
533 {
534 this->x >>= static_cast<T>(scalar);
535 this->y >>= static_cast<T>(scalar);
536 this->z >>= static_cast<T>(scalar);
537 return *this;
538 }
539
540 template<typename T, qualifier Q>
541 template<typename U>
542 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<1, U, Q> const& v)
543 {
544 this->x >>= static_cast<T>(v.x);
545 this->y >>= static_cast<T>(v.x);
546 this->z >>= static_cast<T>(v.x);
547 return *this;
548 }
549
550 template<typename T, qualifier Q>
551 template<typename U>
552 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<3, U, Q> const& v)
553 {
554 this->x >>= static_cast<T>(v.x);
555 this->y >>= static_cast<T>(v.y);
556 this->z >>= static_cast<T>(v.z);
557 return *this;
558 }
559
560 // -- Unary arithmetic operators --
561
562 template<typename T, qualifier Q>
563 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v)
564 {
565 return v;
566 }
567
568 template<typename T, qualifier Q>
569 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v)
570 {
571 return vec<3, T, Q>(
572 -v.x,
573 -v.y,
574 -v.z);
575 }
576
577 // -- Binary arithmetic operators --
578
579 template<typename T, qualifier Q>
580 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar)
581 {
582 return vec<3, T, Q>(
583 v.x + scalar,
584 v.y + scalar,
585 v.z + scalar);
586 }
587
588 template<typename T, qualifier Q>
589 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
590 {
591 return vec<3, T, Q>(
592 v.x + scalar.x,
593 v.y + scalar.x,
594 v.z + scalar.x);
595 }
596
597 template<typename T, qualifier Q>
598 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v)
599 {
600 return vec<3, T, Q>(
601 scalar + v.x,
602 scalar + v.y,
603 scalar + v.z);
604 }
605
606 template<typename T, qualifier Q>
607 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
608 {
609 return vec<3, T, Q>(
610 scalar.x + v.x,
611 scalar.x + v.y,
612 scalar.x + v.z);
613 }
614
615 template<typename T, qualifier Q>
616 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
617 {
618 return vec<3, T, Q>(
619 v1.x + v2.x,
620 v1.y + v2.y,
621 v1.z + v2.z);
622 }
623
624 template<typename T, qualifier Q>
625 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar)
626 {
627 return vec<3, T, Q>(
628 v.x - scalar,
629 v.y - scalar,
630 v.z - scalar);
631 }
632
633 template<typename T, qualifier Q>
634 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
635 {
636 return vec<3, T, Q>(
637 v.x - scalar.x,
638 v.y - scalar.x,
639 v.z - scalar.x);
640 }
641
642 template<typename T, qualifier Q>
643 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v)
644 {
645 return vec<3, T, Q>(
646 scalar - v.x,
647 scalar - v.y,
648 scalar - v.z);
649 }
650
651 template<typename T, qualifier Q>
652 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
653 {
654 return vec<3, T, Q>(
655 scalar.x - v.x,
656 scalar.x - v.y,
657 scalar.x - v.z);
658 }
659
660 template<typename T, qualifier Q>
661 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
662 {
663 return vec<3, T, Q>(
664 v1.x - v2.x,
665 v1.y - v2.y,
666 v1.z - v2.z);
667 }
668
669 template<typename T, qualifier Q>
670 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar)
671 {
672 return vec<3, T, Q>(
673 v.x * scalar,
674 v.y * scalar,
675 v.z * scalar);
676 }
677
678 template<typename T, qualifier Q>
679 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
680 {
681 return vec<3, T, Q>(
682 v.x * scalar.x,
683 v.y * scalar.x,
684 v.z * scalar.x);
685 }
686
687 template<typename T, qualifier Q>
688 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v)
689 {
690 return vec<3, T, Q>(
691 scalar * v.x,
692 scalar * v.y,
693 scalar * v.z);
694 }
695
696 template<typename T, qualifier Q>
697 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
698 {
699 return vec<3, T, Q>(
700 scalar.x * v.x,
701 scalar.x * v.y,
702 scalar.x * v.z);
703 }
704
705 template<typename T, qualifier Q>
706 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
707 {
708 return vec<3, T, Q>(
709 v1.x * v2.x,
710 v1.y * v2.y,
711 v1.z * v2.z);
712 }
713
714 template<typename T, qualifier Q>
715 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar)
716 {
717 return vec<3, T, Q>(
718 v.x / scalar,
719 v.y / scalar,
720 v.z / scalar);
721 }
722
723 template<typename T, qualifier Q>
724 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
725 {
726 return vec<3, T, Q>(
727 v.x / scalar.x,
728 v.y / scalar.x,
729 v.z / scalar.x);
730 }
731
732 template<typename T, qualifier Q>
733 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v)
734 {
735 return vec<3, T, Q>(
736 scalar / v.x,
737 scalar / v.y,
738 scalar / v.z);
739 }
740
741 template<typename T, qualifier Q>
742 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
743 {
744 return vec<3, T, Q>(
745 scalar.x / v.x,
746 scalar.x / v.y,
747 scalar.x / v.z);
748 }
749
750 template<typename T, qualifier Q>
751 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
752 {
753 return vec<3, T, Q>(
754 v1.x / v2.x,
755 v1.y / v2.y,
756 v1.z / v2.z);
757 }
758
759 // -- Binary bit operators --
760
761 template<typename T, qualifier Q>
762 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar)
763 {
764 return vec<3, T, Q>(
765 v.x % scalar,
766 v.y % scalar,
767 v.z % scalar);
768 }
769
770 template<typename T, qualifier Q>
771 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
772 {
773 return vec<3, T, Q>(
774 v.x % scalar.x,
775 v.y % scalar.x,
776 v.z % scalar.x);
777 }
778
779 template<typename T, qualifier Q>
780 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v)
781 {
782 return vec<3, T, Q>(
783 scalar % v.x,
784 scalar % v.y,
785 scalar % v.z);
786 }
787
788 template<typename T, qualifier Q>
789 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
790 {
791 return vec<3, T, Q>(
792 scalar.x % v.x,
793 scalar.x % v.y,
794 scalar.x % v.z);
795 }
796
797 template<typename T, qualifier Q>
798 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
799 {
800 return vec<3, T, Q>(
801 v1.x % v2.x,
802 v1.y % v2.y,
803 v1.z % v2.z);
804 }
805
806 template<typename T, qualifier Q>
807 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, T scalar)
808 {
809 return vec<3, T, Q>(
810 v.x & scalar,
811 v.y & scalar,
812 v.z & scalar);
813 }
814
815 template<typename T, qualifier Q>
816 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
817 {
818 return vec<3, T, Q>(
819 v.x & scalar.x,
820 v.y & scalar.x,
821 v.z & scalar.x);
822 }
823
824 template<typename T, qualifier Q>
825 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v)
826 {
827 return vec<3, T, Q>(
828 scalar & v.x,
829 scalar & v.y,
830 scalar & v.z);
831 }
832
833 template<typename T, qualifier Q>
834 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
835 {
836 return vec<3, T, Q>(
837 scalar.x & v.x,
838 scalar.x & v.y,
839 scalar.x & v.z);
840 }
841
842 template<typename T, qualifier Q>
843 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
844 {
845 return vec<3, T, Q>(
846 v1.x & v2.x,
847 v1.y & v2.y,
848 v1.z & v2.z);
849 }
850
851 template<typename T, qualifier Q>
852 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar)
853 {
854 return vec<3, T, Q>(
855 v.x | scalar,
856 v.y | scalar,
857 v.z | scalar);
858 }
859
860 template<typename T, qualifier Q>
861 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
862 {
863 return vec<3, T, Q>(
864 v.x | scalar.x,
865 v.y | scalar.x,
866 v.z | scalar.x);
867 }
868
869 template<typename T, qualifier Q>
870 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v)
871 {
872 return vec<3, T, Q>(
873 scalar | v.x,
874 scalar | v.y,
875 scalar | v.z);
876 }
877
878 template<typename T, qualifier Q>
879 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
880 {
881 return vec<3, T, Q>(
882 scalar.x | v.x,
883 scalar.x | v.y,
884 scalar.x | v.z);
885 }
886
887 template<typename T, qualifier Q>
888 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
889 {
890 return vec<3, T, Q>(
891 v1.x | v2.x,
892 v1.y | v2.y,
893 v1.z | v2.z);
894 }
895
896 template<typename T, qualifier Q>
897 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar)
898 {
899 return vec<3, T, Q>(
900 v.x ^ scalar,
901 v.y ^ scalar,
902 v.z ^ scalar);
903 }
904
905 template<typename T, qualifier Q>
906 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
907 {
908 return vec<3, T, Q>(
909 v.x ^ scalar.x,
910 v.y ^ scalar.x,
911 v.z ^ scalar.x);
912 }
913
914 template<typename T, qualifier Q>
915 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v)
916 {
917 return vec<3, T, Q>(
918 scalar ^ v.x,
919 scalar ^ v.y,
920 scalar ^ v.z);
921 }
922
923 template<typename T, qualifier Q>
924 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
925 {
926 return vec<3, T, Q>(
927 scalar.x ^ v.x,
928 scalar.x ^ v.y,
929 scalar.x ^ v.z);
930 }
931
932 template<typename T, qualifier Q>
933 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
934 {
935 return vec<3, T, Q>(
936 v1.x ^ v2.x,
937 v1.y ^ v2.y,
938 v1.z ^ v2.z);
939 }
940
941 template<typename T, qualifier Q>
942 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar)
943 {
944 return vec<3, T, Q>(
945 v.x << scalar,
946 v.y << scalar,
947 v.z << scalar);
948 }
949
950 template<typename T, qualifier Q>
951 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
952 {
953 return vec<3, T, Q>(
954 v.x << scalar.x,
955 v.y << scalar.x,
956 v.z << scalar.x);
957 }
958
959 template<typename T, qualifier Q>
960 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v)
961 {
962 return vec<3, T, Q>(
963 scalar << v.x,
964 scalar << v.y,
965 scalar << v.z);
966 }
967
968 template<typename T, qualifier Q>
969 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
970 {
971 return vec<3, T, Q>(
972 scalar.x << v.x,
973 scalar.x << v.y,
974 scalar.x << v.z);
975 }
976
977 template<typename T, qualifier Q>
978 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
979 {
980 return vec<3, T, Q>(
981 v1.x << v2.x,
982 v1.y << v2.y,
983 v1.z << v2.z);
984 }
985
986 template<typename T, qualifier Q>
987 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar)
988 {
989 return vec<3, T, Q>(
990 v.x >> scalar,
991 v.y >> scalar,
992 v.z >> scalar);
993 }
994
995 template<typename T, qualifier Q>
996 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
997 {
998 return vec<3, T, Q>(
999 v.x >> scalar.x,
1000 v.y >> scalar.x,
1001 v.z >> scalar.x);
1002 }
1003
1004 template<typename T, qualifier Q>
1005 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v)
1006 {
1007 return vec<3, T, Q>(
1008 scalar >> v.x,
1009 scalar >> v.y,
1010 scalar >> v.z);
1011 }
1012
1013 template<typename T, qualifier Q>
1014 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
1015 {
1016 return vec<3, T, Q>(
1017 scalar.x >> v.x,
1018 scalar.x >> v.y,
1019 scalar.x >> v.z);
1020 }
1021
1022 template<typename T, qualifier Q>
1023 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
1024 {
1025 return vec<3, T, Q>(
1026 v1.x >> v2.x,
1027 v1.y >> v2.y,
1028 v1.z >> v2.z);
1029 }
1030
1031 template<typename T, qualifier Q>
1032 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v)
1033 {
1034 return vec<3, T, Q>(
1035 ~v.x,
1036 ~v.y,
1037 ~v.z);
1038 }
1039
1040 // -- Boolean operators --
1041
1042 template<typename T, qualifier Q>
1043 GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
1044 {
1045 return
1046 detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
1047 detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
1048 detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z);
1049 }
1050
1051 template<typename T, qualifier Q>
1052 GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
1053 {
1054 return !(v1 == v2);
1055 }
1056
1057 template<qualifier Q>
1058 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
1059 {
1060 return vec<3, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
1061 }
1062
1063 template<qualifier Q>
1064 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
1065 {
1066 return vec<3, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);
1067 }
1068 }//namespace glm
1069