Clutter Engine 0.0.1
Loading...
Searching...
No Matches
euler_angles.inl
1
2
3#include "compatibility.hpp" // glm::atan2
4
5namespace glm
6{
7 template<typename T>
8 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleX
9 (
10 T const& angleX
11 )
12 {
13 T cosX = glm::cos(angleX);
14 T sinX = glm::sin(angleX);
15
16 return mat<4, 4, T, defaultp>(
17 T(1), T(0), T(0), T(0),
18 T(0), cosX, sinX, T(0),
19 T(0),-sinX, cosX, T(0),
20 T(0), T(0), T(0), T(1));
21 }
22
23 template<typename T>
24 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleY
25 (
26 T const& angleY
27 )
28 {
29 T cosY = glm::cos(angleY);
30 T sinY = glm::sin(angleY);
31
32 return mat<4, 4, T, defaultp>(
33 cosY, T(0), -sinY, T(0),
34 T(0), T(1), T(0), T(0),
35 sinY, T(0), cosY, T(0),
36 T(0), T(0), T(0), T(1));
37 }
38
39 template<typename T>
40 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZ
41 (
42 T const& angleZ
43 )
44 {
45 T cosZ = glm::cos(angleZ);
46 T sinZ = glm::sin(angleZ);
47
48 return mat<4, 4, T, defaultp>(
49 cosZ, sinZ, T(0), T(0),
50 -sinZ, cosZ, T(0), T(0),
51 T(0), T(0), T(1), T(0),
52 T(0), T(0), T(0), T(1));
53 }
54
55 template <typename T>
56 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleX
57 (
58 T const & angleX,
59 T const & angularVelocityX
60 )
61 {
62 T cosX = glm::cos(angleX) * angularVelocityX;
63 T sinX = glm::sin(angleX) * angularVelocityX;
64
65 return mat<4, 4, T, defaultp>(
66 T(0), T(0), T(0), T(0),
67 T(0),-sinX, cosX, T(0),
68 T(0),-cosX,-sinX, T(0),
69 T(0), T(0), T(0), T(0));
70 }
71
72 template <typename T>
73 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleY
74 (
75 T const & angleY,
76 T const & angularVelocityY
77 )
78 {
79 T cosY = glm::cos(angleY) * angularVelocityY;
80 T sinY = glm::sin(angleY) * angularVelocityY;
81
82 return mat<4, 4, T, defaultp>(
83 -sinY, T(0), -cosY, T(0),
84 T(0), T(0), T(0), T(0),
85 cosY, T(0), -sinY, T(0),
86 T(0), T(0), T(0), T(0));
87 }
88
89 template <typename T>
90 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleZ
91 (
92 T const & angleZ,
93 T const & angularVelocityZ
94 )
95 {
96 T cosZ = glm::cos(angleZ) * angularVelocityZ;
97 T sinZ = glm::sin(angleZ) * angularVelocityZ;
98
99 return mat<4, 4, T, defaultp>(
100 -sinZ, cosZ, T(0), T(0),
101 -cosZ, -sinZ, T(0), T(0),
102 T(0), T(0), T(0), T(0),
103 T(0), T(0), T(0), T(0));
104 }
105
106 template<typename T>
107 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXY
108 (
109 T const& angleX,
110 T const& angleY
111 )
112 {
113 T cosX = glm::cos(angleX);
114 T sinX = glm::sin(angleX);
115 T cosY = glm::cos(angleY);
116 T sinY = glm::sin(angleY);
117
118 return mat<4, 4, T, defaultp>(
119 cosY, -sinX * -sinY, cosX * -sinY, T(0),
120 T(0), cosX, sinX, T(0),
121 sinY, -sinX * cosY, cosX * cosY, T(0),
122 T(0), T(0), T(0), T(1));
123 }
124
125 template<typename T>
126 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYX
127 (
128 T const& angleY,
129 T const& angleX
130 )
131 {
132 T cosX = glm::cos(angleX);
133 T sinX = glm::sin(angleX);
134 T cosY = glm::cos(angleY);
135 T sinY = glm::sin(angleY);
136
137 return mat<4, 4, T, defaultp>(
138 cosY, 0, -sinY, T(0),
139 sinY * sinX, cosX, cosY * sinX, T(0),
140 sinY * cosX, -sinX, cosY * cosX, T(0),
141 T(0), T(0), T(0), T(1));
142 }
143
144 template<typename T>
145 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZ
146 (
147 T const& angleX,
148 T const& angleZ
149 )
150 {
151 return eulerAngleX(angleX) * eulerAngleZ(angleZ);
152 }
153
154 template<typename T>
155 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZX
156 (
157 T const& angleZ,
158 T const& angleX
159 )
160 {
161 return eulerAngleZ(angleZ) * eulerAngleX(angleX);
162 }
163
164 template<typename T>
165 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZ
166 (
167 T const& angleY,
168 T const& angleZ
169 )
170 {
171 return eulerAngleY(angleY) * eulerAngleZ(angleZ);
172 }
173
174 template<typename T>
175 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZY
176 (
177 T const& angleZ,
178 T const& angleY
179 )
180 {
181 return eulerAngleZ(angleZ) * eulerAngleY(angleY);
182 }
183
184 template<typename T>
185 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYZ
186 (
187 T const& t1,
188 T const& t2,
189 T const& t3
190 )
191 {
192 T c1 = glm::cos(-t1);
193 T c2 = glm::cos(-t2);
194 T c3 = glm::cos(-t3);
195 T s1 = glm::sin(-t1);
196 T s2 = glm::sin(-t2);
197 T s3 = glm::sin(-t3);
198
199 mat<4, 4, T, defaultp> Result;
200 Result[0][0] = c2 * c3;
201 Result[0][1] =-c1 * s3 + s1 * s2 * c3;
202 Result[0][2] = s1 * s3 + c1 * s2 * c3;
203 Result[0][3] = static_cast<T>(0);
204 Result[1][0] = c2 * s3;
205 Result[1][1] = c1 * c3 + s1 * s2 * s3;
206 Result[1][2] =-s1 * c3 + c1 * s2 * s3;
207 Result[1][3] = static_cast<T>(0);
208 Result[2][0] =-s2;
209 Result[2][1] = s1 * c2;
210 Result[2][2] = c1 * c2;
211 Result[2][3] = static_cast<T>(0);
212 Result[3][0] = static_cast<T>(0);
213 Result[3][1] = static_cast<T>(0);
214 Result[3][2] = static_cast<T>(0);
215 Result[3][3] = static_cast<T>(1);
216 return Result;
217 }
218
219 template<typename T>
220 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXZ
221 (
222 T const& yaw,
223 T const& pitch,
224 T const& roll
225 )
226 {
227 T tmp_ch = glm::cos(yaw);
228 T tmp_sh = glm::sin(yaw);
229 T tmp_cp = glm::cos(pitch);
230 T tmp_sp = glm::sin(pitch);
231 T tmp_cb = glm::cos(roll);
232 T tmp_sb = glm::sin(roll);
233
234 mat<4, 4, T, defaultp> Result;
235 Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
236 Result[0][1] = tmp_sb * tmp_cp;
237 Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
238 Result[0][3] = static_cast<T>(0);
239 Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
240 Result[1][1] = tmp_cb * tmp_cp;
241 Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
242 Result[1][3] = static_cast<T>(0);
243 Result[2][0] = tmp_sh * tmp_cp;
244 Result[2][1] = -tmp_sp;
245 Result[2][2] = tmp_ch * tmp_cp;
246 Result[2][3] = static_cast<T>(0);
247 Result[3][0] = static_cast<T>(0);
248 Result[3][1] = static_cast<T>(0);
249 Result[3][2] = static_cast<T>(0);
250 Result[3][3] = static_cast<T>(1);
251 return Result;
252 }
253
254 template <typename T>
255 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZX
256 (
257 T const & t1,
258 T const & t2,
259 T const & t3
260 )
261 {
262 T c1 = glm::cos(t1);
263 T s1 = glm::sin(t1);
264 T c2 = glm::cos(t2);
265 T s2 = glm::sin(t2);
266 T c3 = glm::cos(t3);
267 T s3 = glm::sin(t3);
268
269 mat<4, 4, T, defaultp> Result;
270 Result[0][0] = c2;
271 Result[0][1] = c1 * s2;
272 Result[0][2] = s1 * s2;
273 Result[0][3] = static_cast<T>(0);
274 Result[1][0] =-c3 * s2;
275 Result[1][1] = c1 * c2 * c3 - s1 * s3;
276 Result[1][2] = c1 * s3 + c2 * c3 * s1;
277 Result[1][3] = static_cast<T>(0);
278 Result[2][0] = s2 * s3;
279 Result[2][1] =-c3 * s1 - c1 * c2 * s3;
280 Result[2][2] = c1 * c3 - c2 * s1 * s3;
281 Result[2][3] = static_cast<T>(0);
282 Result[3][0] = static_cast<T>(0);
283 Result[3][1] = static_cast<T>(0);
284 Result[3][2] = static_cast<T>(0);
285 Result[3][3] = static_cast<T>(1);
286 return Result;
287 }
288
289 template <typename T>
290 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYX
291 (
292 T const & t1,
293 T const & t2,
294 T const & t3
295 )
296 {
297 T c1 = glm::cos(t1);
298 T s1 = glm::sin(t1);
299 T c2 = glm::cos(t2);
300 T s2 = glm::sin(t2);
301 T c3 = glm::cos(t3);
302 T s3 = glm::sin(t3);
303
304 mat<4, 4, T, defaultp> Result;
305 Result[0][0] = c2;
306 Result[0][1] = s1 * s2;
307 Result[0][2] =-c1 * s2;
308 Result[0][3] = static_cast<T>(0);
309 Result[1][0] = s2 * s3;
310 Result[1][1] = c1 * c3 - c2 * s1 * s3;
311 Result[1][2] = c3 * s1 + c1 * c2 * s3;
312 Result[1][3] = static_cast<T>(0);
313 Result[2][0] = c3 * s2;
314 Result[2][1] =-c1 * s3 - c2 * c3 * s1;
315 Result[2][2] = c1 * c2 * c3 - s1 * s3;
316 Result[2][3] = static_cast<T>(0);
317 Result[3][0] = static_cast<T>(0);
318 Result[3][1] = static_cast<T>(0);
319 Result[3][2] = static_cast<T>(0);
320 Result[3][3] = static_cast<T>(1);
321 return Result;
322 }
323
324 template <typename T>
325 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXY
326 (
327 T const & t1,
328 T const & t2,
329 T const & t3
330 )
331 {
332 T c1 = glm::cos(t1);
333 T s1 = glm::sin(t1);
334 T c2 = glm::cos(t2);
335 T s2 = glm::sin(t2);
336 T c3 = glm::cos(t3);
337 T s3 = glm::sin(t3);
338
339 mat<4, 4, T, defaultp> Result;
340 Result[0][0] = c1 * c3 - c2 * s1 * s3;
341 Result[0][1] = s2* s3;
342 Result[0][2] =-c3 * s1 - c1 * c2 * s3;
343 Result[0][3] = static_cast<T>(0);
344 Result[1][0] = s1 * s2;
345 Result[1][1] = c2;
346 Result[1][2] = c1 * s2;
347 Result[1][3] = static_cast<T>(0);
348 Result[2][0] = c1 * s3 + c2 * c3 * s1;
349 Result[2][1] =-c3 * s2;
350 Result[2][2] = c1 * c2 * c3 - s1 * s3;
351 Result[2][3] = static_cast<T>(0);
352 Result[3][0] = static_cast<T>(0);
353 Result[3][1] = static_cast<T>(0);
354 Result[3][2] = static_cast<T>(0);
355 Result[3][3] = static_cast<T>(1);
356 return Result;
357 }
358
359 template <typename T>
360 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZY
361 (
362 T const & t1,
363 T const & t2,
364 T const & t3
365 )
366 {
367 T c1 = glm::cos(t1);
368 T s1 = glm::sin(t1);
369 T c2 = glm::cos(t2);
370 T s2 = glm::sin(t2);
371 T c3 = glm::cos(t3);
372 T s3 = glm::sin(t3);
373
374 mat<4, 4, T, defaultp> Result;
375 Result[0][0] = c1 * c2 * c3 - s1 * s3;
376 Result[0][1] = c3 * s2;
377 Result[0][2] =-c1 * s3 - c2 * c3 * s1;
378 Result[0][3] = static_cast<T>(0);
379 Result[1][0] =-c1 * s2;
380 Result[1][1] = c2;
381 Result[1][2] = s1 * s2;
382 Result[1][3] = static_cast<T>(0);
383 Result[2][0] = c3 * s1 + c1 * c2 * s3;
384 Result[2][1] = s2 * s3;
385 Result[2][2] = c1 * c3 - c2 * s1 * s3;
386 Result[2][3] = static_cast<T>(0);
387 Result[3][0] = static_cast<T>(0);
388 Result[3][1] = static_cast<T>(0);
389 Result[3][2] = static_cast<T>(0);
390 Result[3][3] = static_cast<T>(1);
391 return Result;
392 }
393
394 template <typename T>
395 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYZ
396 (
397 T const & t1,
398 T const & t2,
399 T const & t3
400 )
401 {
402 T c1 = glm::cos(t1);
403 T s1 = glm::sin(t1);
404 T c2 = glm::cos(t2);
405 T s2 = glm::sin(t2);
406 T c3 = glm::cos(t3);
407 T s3 = glm::sin(t3);
408
409 mat<4, 4, T, defaultp> Result;
410 Result[0][0] = c1 * c2 * c3 - s1 * s3;
411 Result[0][1] = c1 * s3 + c2 * c3 * s1;
412 Result[0][2] =-c3 * s2;
413 Result[0][3] = static_cast<T>(0);
414 Result[1][0] =-c3 * s1 - c1 * c2 * s3;
415 Result[1][1] = c1 * c3 - c2 * s1 * s3;
416 Result[1][2] = s2 * s3;
417 Result[1][3] = static_cast<T>(0);
418 Result[2][0] = c1 * s2;
419 Result[2][1] = s1 * s2;
420 Result[2][2] = c2;
421 Result[2][3] = static_cast<T>(0);
422 Result[3][0] = static_cast<T>(0);
423 Result[3][1] = static_cast<T>(0);
424 Result[3][2] = static_cast<T>(0);
425 Result[3][3] = static_cast<T>(1);
426 return Result;
427 }
428
429 template <typename T>
430 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXZ
431 (
432 T const & t1,
433 T const & t2,
434 T const & t3
435 )
436 {
437 T c1 = glm::cos(t1);
438 T s1 = glm::sin(t1);
439 T c2 = glm::cos(t2);
440 T s2 = glm::sin(t2);
441 T c3 = glm::cos(t3);
442 T s3 = glm::sin(t3);
443
444 mat<4, 4, T, defaultp> Result;
445 Result[0][0] = c1 * c3 - c2 * s1 * s3;
446 Result[0][1] = c3 * s1 + c1 * c2 * s3;
447 Result[0][2] = s2 *s3;
448 Result[0][3] = static_cast<T>(0);
449 Result[1][0] =-c1 * s3 - c2 * c3 * s1;
450 Result[1][1] = c1 * c2 * c3 - s1 * s3;
451 Result[1][2] = c3 * s2;
452 Result[1][3] = static_cast<T>(0);
453 Result[2][0] = s1 * s2;
454 Result[2][1] =-c1 * s2;
455 Result[2][2] = c2;
456 Result[2][3] = static_cast<T>(0);
457 Result[3][0] = static_cast<T>(0);
458 Result[3][1] = static_cast<T>(0);
459 Result[3][2] = static_cast<T>(0);
460 Result[3][3] = static_cast<T>(1);
461 return Result;
462 }
463
464 template <typename T>
465 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZY
466 (
467 T const & t1,
468 T const & t2,
469 T const & t3
470 )
471 {
472 T c1 = glm::cos(t1);
473 T s1 = glm::sin(t1);
474 T c2 = glm::cos(t2);
475 T s2 = glm::sin(t2);
476 T c3 = glm::cos(t3);
477 T s3 = glm::sin(t3);
478
479 mat<4, 4, T, defaultp> Result;
480 Result[0][0] = c2 * c3;
481 Result[0][1] = s1 * s3 + c1 * c3 * s2;
482 Result[0][2] = c3 * s1 * s2 - c1 * s3;
483 Result[0][3] = static_cast<T>(0);
484 Result[1][0] =-s2;
485 Result[1][1] = c1 * c2;
486 Result[1][2] = c2 * s1;
487 Result[1][3] = static_cast<T>(0);
488 Result[2][0] = c2 * s3;
489 Result[2][1] = c1 * s2 * s3 - c3 * s1;
490 Result[2][2] = c1 * c3 + s1 * s2 *s3;
491 Result[2][3] = static_cast<T>(0);
492 Result[3][0] = static_cast<T>(0);
493 Result[3][1] = static_cast<T>(0);
494 Result[3][2] = static_cast<T>(0);
495 Result[3][3] = static_cast<T>(1);
496 return Result;
497 }
498
499 template <typename T>
500 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZX
501 (
502 T const & t1,
503 T const & t2,
504 T const & t3
505 )
506 {
507 T c1 = glm::cos(t1);
508 T s1 = glm::sin(t1);
509 T c2 = glm::cos(t2);
510 T s2 = glm::sin(t2);
511 T c3 = glm::cos(t3);
512 T s3 = glm::sin(t3);
513
514 mat<4, 4, T, defaultp> Result;
515 Result[0][0] = c1 * c2;
516 Result[0][1] = s2;
517 Result[0][2] =-c2 * s1;
518 Result[0][3] = static_cast<T>(0);
519 Result[1][0] = s1 * s3 - c1 * c3 * s2;
520 Result[1][1] = c2 * c3;
521 Result[1][2] = c1 * s3 + c3 * s1 * s2;
522 Result[1][3] = static_cast<T>(0);
523 Result[2][0] = c3 * s1 + c1 * s2 * s3;
524 Result[2][1] =-c2 * s3;
525 Result[2][2] = c1 * c3 - s1 * s2 * s3;
526 Result[2][3] = static_cast<T>(0);
527 Result[3][0] = static_cast<T>(0);
528 Result[3][1] = static_cast<T>(0);
529 Result[3][2] = static_cast<T>(0);
530 Result[3][3] = static_cast<T>(1);
531 return Result;
532 }
533
534 template <typename T>
535 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYX
536 (
537 T const & t1,
538 T const & t2,
539 T const & t3
540 )
541 {
542 T c1 = glm::cos(t1);
543 T s1 = glm::sin(t1);
544 T c2 = glm::cos(t2);
545 T s2 = glm::sin(t2);
546 T c3 = glm::cos(t3);
547 T s3 = glm::sin(t3);
548
549 mat<4, 4, T, defaultp> Result;
550 Result[0][0] = c1 * c2;
551 Result[0][1] = c2 * s1;
552 Result[0][2] =-s2;
553 Result[0][3] = static_cast<T>(0);
554 Result[1][0] = c1 * s2 * s3 - c3 * s1;
555 Result[1][1] = c1 * c3 + s1 * s2 * s3;
556 Result[1][2] = c2 * s3;
557 Result[1][3] = static_cast<T>(0);
558 Result[2][0] = s1 * s3 + c1 * c3 * s2;
559 Result[2][1] = c3 * s1 * s2 - c1 * s3;
560 Result[2][2] = c2 * c3;
561 Result[2][3] = static_cast<T>(0);
562 Result[3][0] = static_cast<T>(0);
563 Result[3][1] = static_cast<T>(0);
564 Result[3][2] = static_cast<T>(0);
565 Result[3][3] = static_cast<T>(1);
566 return Result;
567 }
568
569 template <typename T>
570 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXY
571 (
572 T const & t1,
573 T const & t2,
574 T const & t3
575 )
576 {
577 T c1 = glm::cos(t1);
578 T s1 = glm::sin(t1);
579 T c2 = glm::cos(t2);
580 T s2 = glm::sin(t2);
581 T c3 = glm::cos(t3);
582 T s3 = glm::sin(t3);
583
584 mat<4, 4, T, defaultp> Result;
585 Result[0][0] = c1 * c3 - s1 * s2 * s3;
586 Result[0][1] = c3 * s1 + c1 * s2 * s3;
587 Result[0][2] =-c2 * s3;
588 Result[0][3] = static_cast<T>(0);
589 Result[1][0] =-c2 * s1;
590 Result[1][1] = c1 * c2;
591 Result[1][2] = s2;
592 Result[1][3] = static_cast<T>(0);
593 Result[2][0] = c1 * s3 + c3 * s1 * s2;
594 Result[2][1] = s1 * s3 - c1 * c3 * s2;
595 Result[2][2] = c2 * c3;
596 Result[2][3] = static_cast<T>(0);
597 Result[3][0] = static_cast<T>(0);
598 Result[3][1] = static_cast<T>(0);
599 Result[3][2] = static_cast<T>(0);
600 Result[3][3] = static_cast<T>(1);
601 return Result;
602 }
603
604 template<typename T>
605 GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> yawPitchRoll
606 (
607 T const& yaw,
608 T const& pitch,
609 T const& roll
610 )
611 {
612 T tmp_ch = glm::cos(yaw);
613 T tmp_sh = glm::sin(yaw);
614 T tmp_cp = glm::cos(pitch);
615 T tmp_sp = glm::sin(pitch);
616 T tmp_cb = glm::cos(roll);
617 T tmp_sb = glm::sin(roll);
618
619 mat<4, 4, T, defaultp> Result;
620 Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
621 Result[0][1] = tmp_sb * tmp_cp;
622 Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
623 Result[0][3] = static_cast<T>(0);
624 Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
625 Result[1][1] = tmp_cb * tmp_cp;
626 Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
627 Result[1][3] = static_cast<T>(0);
628 Result[2][0] = tmp_sh * tmp_cp;
629 Result[2][1] = -tmp_sp;
630 Result[2][2] = tmp_ch * tmp_cp;
631 Result[2][3] = static_cast<T>(0);
632 Result[3][0] = static_cast<T>(0);
633 Result[3][1] = static_cast<T>(0);
634 Result[3][2] = static_cast<T>(0);
635 Result[3][3] = static_cast<T>(1);
636 return Result;
637 }
638
639 template<typename T>
640 GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> orientate2
641 (
642 T const& angle
643 )
644 {
645 T c = glm::cos(angle);
646 T s = glm::sin(angle);
647
648 mat<2, 2, T, defaultp> Result;
649 Result[0][0] = c;
650 Result[0][1] = s;
651 Result[1][0] = -s;
652 Result[1][1] = c;
653 return Result;
654 }
655
656 template<typename T>
657 GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> orientate3
658 (
659 T const& angle
660 )
661 {
662 T c = glm::cos(angle);
663 T s = glm::sin(angle);
664
665 mat<3, 3, T, defaultp> Result;
666 Result[0][0] = c;
667 Result[0][1] = s;
668 Result[0][2] = 0.0f;
669 Result[1][0] = -s;
670 Result[1][1] = c;
671 Result[1][2] = 0.0f;
672 Result[2][0] = 0.0f;
673 Result[2][1] = 0.0f;
674 Result[2][2] = 1.0f;
675 return Result;
676 }
677
678 template<typename T, qualifier Q>
679 GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orientate3
680 (
681 vec<3, T, Q> const& angles
682 )
683 {
684 return mat<3, 3, T, Q>(yawPitchRoll(angles.z, angles.x, angles.y));
685 }
686
687 template<typename T, qualifier Q>
688 GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientate4
689 (
690 vec<3, T, Q> const& angles
691 )
692 {
693 return yawPitchRoll(angles.z, angles.x, angles.y);
694 }
695
696 template<typename T>
697 GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M,
698 T & t1,
699 T & t2,
700 T & t3)
701 {
702 T T1 = glm::atan2<T, defaultp>(M[2][1], M[2][2]);
703 T C2 = glm::sqrt(M[0][0]*M[0][0] + M[1][0]*M[1][0]);
704 T T2 = glm::atan2<T, defaultp>(-M[2][0], C2);
705 T S1 = glm::sin(T1);
706 T C1 = glm::cos(T1);
707 T T3 = glm::atan2<T, defaultp>(S1*M[0][2] - C1*M[0][1], C1*M[1][1] - S1*M[1][2 ]);
708 t1 = -T1;
709 t2 = -T2;
710 t3 = -T3;
711 }
712
713 template <typename T>
714 GLM_FUNC_QUALIFIER void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M,
715 T & t1,
716 T & t2,
717 T & t3)
718 {
719 T T1 = glm::atan2<T, defaultp>(M[2][0], M[2][2]);
720 T C2 = glm::sqrt(M[0][1]*M[0][1] + M[1][1]*M[1][1]);
721 T T2 = glm::atan2<T, defaultp>(-M[2][1], C2);
722 T S1 = glm::sin(T1);
723 T C1 = glm::cos(T1);
724 T T3 = glm::atan2<T, defaultp>(S1*M[1][2] - C1*M[1][0], C1*M[0][0] - S1*M[0][2]);
725 t1 = T1;
726 t2 = T2;
727 t3 = T3;
728 }
729
730 template <typename T>
731 GLM_FUNC_QUALIFIER void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M,
732 T & t1,
733 T & t2,
734 T & t3)
735 {
736 T T1 = glm::atan2<T, defaultp>(M[0][2], M[0][1]);
737 T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]);
738 T T2 = glm::atan2<T, defaultp>(S2, M[0][0]);
739 T S1 = glm::sin(T1);
740 T C1 = glm::cos(T1);
741 T T3 = glm::atan2<T, defaultp>(C1*M[1][2] - S1*M[1][1], C1*M[2][2] - S1*M[2][1]);
742 t1 = T1;
743 t2 = T2;
744 t3 = T3;
745 }
746
747 template <typename T>
748 GLM_FUNC_QUALIFIER void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M,
749 T & t1,
750 T & t2,
751 T & t3)
752 {
753 T T1 = glm::atan2<T, defaultp>(M[0][1], -M[0][2]);
754 T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]);
755 T T2 = glm::atan2<T, defaultp>(S2, M[0][0]);
756 T S1 = glm::sin(T1);
757 T C1 = glm::cos(T1);
758 T T3 = glm::atan2<T, defaultp>(-C1*M[2][1] - S1*M[2][2], C1*M[1][1] + S1*M[1][2]);
759 t1 = T1;
760 t2 = T2;
761 t3 = T3;
762 }
763
764 template <typename T>
765 GLM_FUNC_QUALIFIER void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M,
766 T & t1,
767 T & t2,
768 T & t3)
769 {
770 T T1 = glm::atan2<T, defaultp>(M[1][0], M[1][2]);
771 T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]);
772 T T2 = glm::atan2<T, defaultp>(S2, M[1][1]);
773 T S1 = glm::sin(T1);
774 T C1 = glm::cos(T1);
775 T T3 = glm::atan2<T, defaultp>(C1*M[2][0] - S1*M[2][2], C1*M[0][0] - S1*M[0][2]);
776 t1 = T1;
777 t2 = T2;
778 t3 = T3;
779 }
780
781 template <typename T>
782 GLM_FUNC_QUALIFIER void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M,
783 T & t1,
784 T & t2,
785 T & t3)
786 {
787 T T1 = glm::atan2<T, defaultp>(M[1][2], -M[1][0]);
788 T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]);
789 T T2 = glm::atan2<T, defaultp>(S2, M[1][1]);
790 T S1 = glm::sin(T1);
791 T C1 = glm::cos(T1);
792 T T3 = glm::atan2<T, defaultp>(-S1*M[0][0] - C1*M[0][2], S1*M[2][0] + C1*M[2][2]);
793 t1 = T1;
794 t2 = T2;
795 t3 = T3;
796 }
797
798 template <typename T>
799 GLM_FUNC_QUALIFIER void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M,
800 T & t1,
801 T & t2,
802 T & t3)
803 {
804 T T1 = glm::atan2<T, defaultp>(M[2][1], M[2][0]);
805 T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]);
806 T T2 = glm::atan2<T, defaultp>(S2, M[2][2]);
807 T S1 = glm::sin(T1);
808 T C1 = glm::cos(T1);
809 T T3 = glm::atan2<T, defaultp>(C1*M[0][1] - S1*M[0][0], C1*M[1][1] - S1*M[1][0]);
810 t1 = T1;
811 t2 = T2;
812 t3 = T3;
813 }
814
815 template <typename T>
816 GLM_FUNC_QUALIFIER void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M,
817 T & t1,
818 T & t2,
819 T & t3)
820 {
821 T T1 = glm::atan2<T, defaultp>(M[2][0], -M[2][1]);
822 T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]);
823 T T2 = glm::atan2<T, defaultp>(S2, M[2][2]);
824 T S1 = glm::sin(T1);
825 T C1 = glm::cos(T1);
826 T T3 = glm::atan2<T, defaultp>(-C1*M[1][0] - S1*M[1][1], C1*M[0][0] + S1*M[0][1]);
827 t1 = T1;
828 t2 = T2;
829 t3 = T3;
830 }
831
832 template <typename T>
833 GLM_FUNC_QUALIFIER void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M,
834 T & t1,
835 T & t2,
836 T & t3)
837 {
838 T T1 = glm::atan2<T, defaultp>(M[1][2], M[1][1]);
839 T C2 = glm::sqrt(M[0][0]*M[0][0] + M[2][0]*M[2][0]);
840 T T2 = glm::atan2<T, defaultp>(-M[1][0], C2);
841 T S1 = glm::sin(T1);
842 T C1 = glm::cos(T1);
843 T T3 = glm::atan2<T, defaultp>(S1*M[0][1] - C1*M[0][2], C1*M[2][2] - S1*M[2][1]);
844 t1 = T1;
845 t2 = T2;
846 t3 = T3;
847 }
848
849 template <typename T>
850 GLM_FUNC_QUALIFIER void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M,
851 T & t1,
852 T & t2,
853 T & t3)
854 {
855 T T1 = glm::atan2<T, defaultp>(-M[0][2], M[0][0]);
856 T C2 = glm::sqrt(M[1][1]*M[1][1] + M[2][1]*M[2][1]);
857 T T2 = glm::atan2<T, defaultp>(M[0][1], C2);
858 T S1 = glm::sin(T1);
859 T C1 = glm::cos(T1);
860 T T3 = glm::atan2<T, defaultp>(S1*M[1][0] + C1*M[1][2], S1*M[2][0] + C1*M[2][2]);
861 t1 = T1;
862 t2 = T2;
863 t3 = T3;
864 }
865
866 template <typename T>
867 GLM_FUNC_QUALIFIER void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M,
868 T & t1,
869 T & t2,
870 T & t3)
871 {
872 T T1 = glm::atan2<T, defaultp>(M[0][1], M[0][0]);
873 T C2 = glm::sqrt(M[1][2]*M[1][2] + M[2][2]*M[2][2]);
874 T T2 = glm::atan2<T, defaultp>(-M[0][2], C2);
875 T S1 = glm::sin(T1);
876 T C1 = glm::cos(T1);
877 T T3 = glm::atan2<T, defaultp>(S1*M[2][0] - C1*M[2][1], C1*M[1][1] - S1*M[1][0]);
878 t1 = T1;
879 t2 = T2;
880 t3 = T3;
881 }
882
883 template <typename T>
884 GLM_FUNC_QUALIFIER void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M,
885 T & t1,
886 T & t2,
887 T & t3)
888 {
889 T T1 = glm::atan2<T, defaultp>(-M[1][0], M[1][1]);
890 T C2 = glm::sqrt(M[0][2]*M[0][2] + M[2][2]*M[2][2]);
891 T T2 = glm::atan2<T, defaultp>(M[1][2], C2);
892 T S1 = glm::sin(T1);
893 T C1 = glm::cos(T1);
894 T T3 = glm::atan2<T, defaultp>(C1*M[2][0] + S1*M[2][1], C1*M[0][0] + S1*M[0][1]);
895 t1 = T1;
896 t2 = T2;
897 t3 = T3;
898 }
899}//namespace glm
glm::sqrt
GLM_FUNC_QUALIFIER vec< L, T, Q > sqrt(vec< L, T, Q > const &x)
Definition func_exponential.inl:128
glm::sin
GLM_FUNC_QUALIFIER vec< L, T, Q > sin(vec< L, T, Q > const &v)
Definition func_trigonometric.inl:41
glm::cos
GLM_FUNC_QUALIFIER vec< L, T, Q > cos(vec< L, T, Q > const &v)
Definition func_trigonometric.inl:50
glm::angle
GLM_FUNC_DECL T angle(qua< T, Q > const &x)
Definition quaternion_trigonometric.inl:6
glm::roll
GLM_FUNC_DECL T roll(qua< T, Q > const &x)
Definition quaternion.inl:16
glm::pitch
GLM_FUNC_DECL T pitch(qua< T, Q > const &x)
Definition quaternion.inl:22
glm::yaw
GLM_FUNC_DECL T yaw(qua< T, Q > const &x)
Definition quaternion.inl:35
glm::atan2
GLM_FUNC_QUALIFIER T atan2(T x, T y)
Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what q...
Definition compatibility.hpp:55
glm::eulerAngleY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleY(T const &angleY)
Definition euler_angles.inl:25
glm::extractEulerAngleYZY
GLM_FUNC_DECL void extractEulerAngleYZY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:782
glm::eulerAngleXY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXY(T const &angleX, T const &angleY)
Definition euler_angles.inl:108
glm::extractEulerAngleZYX
GLM_FUNC_DECL void extractEulerAngleZYX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:867
glm::derivedEulerAngleY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleY(T const &angleY, T const &angularVelocityY)
Definition euler_angles.inl:74
glm::eulerAngleYZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZ(T const &angleY, T const &angleZ)
Definition euler_angles.inl:166
glm::eulerAngleYXZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXZ(T const &yaw, T const &pitch, T const &roll)
Definition euler_angles.inl:221
glm::eulerAngleYXY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYXY(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:326
glm::eulerAngleXYZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYZ(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:186
glm::eulerAngleXYX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXYX(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:291
glm::eulerAngleZYZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYZ(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:396
glm::extractEulerAngleZXZ
GLM_FUNC_DECL void extractEulerAngleZXZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:816
glm::eulerAngleYZY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZY(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:361
glm::eulerAngleXZY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZY(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:466
glm::eulerAngleX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleX(T const &angleX)
Definition euler_angles.inl:9
glm::extractEulerAngleZXY
GLM_FUNC_DECL void extractEulerAngleZXY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:884
glm::eulerAngleZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZ(T const &angleZ)
Definition euler_angles.inl:41
glm::extractEulerAngleYZX
GLM_FUNC_DECL void extractEulerAngleYZX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:850
glm::extractEulerAngleYXY
GLM_FUNC_DECL void extractEulerAngleYXY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:765
glm::eulerAngleXZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZ(T const &angleX, T const &angleZ)
Definition euler_angles.inl:146
glm::eulerAngleZYX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZYX(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:536
glm::eulerAngleZXZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXZ(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:431
glm::extractEulerAngleXZY
GLM_FUNC_DECL void extractEulerAngleXZY(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:833
glm::eulerAngleZXY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZXY(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:571
glm::eulerAngleYZX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYZX(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:501
glm::extractEulerAngleXYZ
GLM_FUNC_DECL void extractEulerAngleXYZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:697
glm::extractEulerAngleXZX
GLM_FUNC_DECL void extractEulerAngleXZX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:731
glm::orientate2
GLM_FUNC_DECL mat< 2, 2, T, defaultp > orientate2(T const &angle)
Definition euler_angles.inl:641
glm::orientate3
GLM_FUNC_DECL mat< 3, 3, T, defaultp > orientate3(T const &angle)
Definition euler_angles.inl:658
glm::eulerAngleZY
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZY(T const &angleZ, T const &angleY)
Definition euler_angles.inl:176
glm::derivedEulerAngleX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleX(T const &angleX, T const &angularVelocityX)
Definition euler_angles.inl:57
glm::derivedEulerAngleZ
GLM_FUNC_DECL mat< 4, 4, T, defaultp > derivedEulerAngleZ(T const &angleZ, T const &angularVelocityZ)
Definition euler_angles.inl:91
glm::eulerAngleXZX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleXZX(T const &t1, T const &t2, T const &t3)
Definition euler_angles.inl:256
glm::eulerAngleYX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleYX(T const &angleY, T const &angleX)
Definition euler_angles.inl:127
glm::extractEulerAngleYXZ
GLM_FUNC_DECL void extractEulerAngleYXZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:714
glm::extractEulerAngleXYX
GLM_FUNC_DECL void extractEulerAngleXYX(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:748
glm::eulerAngleZX
GLM_FUNC_DECL mat< 4, 4, T, defaultp > eulerAngleZX(T const &angle, T const &angleX)
Definition euler_angles.inl:156
glm::orientate4
GLM_FUNC_DECL mat< 4, 4, T, Q > orientate4(vec< 3, T, Q > const &angles)
Definition euler_angles.inl:689
glm::yawPitchRoll
GLM_FUNC_DECL mat< 4, 4, T, defaultp > yawPitchRoll(T const &yaw, T const &pitch, T const &roll)
Definition euler_angles.inl:606
glm::extractEulerAngleZYZ
GLM_FUNC_DECL void extractEulerAngleZYZ(mat< 4, 4, T, defaultp > const &M, T &t1, T &t2, T &t3)
Definition euler_angles.inl:799
glm
Core features
Definition common.hpp:21
glm::mat
Definition qualifier.hpp:36
glm::vec
Definition qualifier.hpp:35
Generated by doxygen 1.12.0