suwako / VulkanExample

master
ブランチ master
VulkanExample / dep / include / glm / gtx / euler_angles.hpp
10.8 KB、333行 生 Blame 履歴
1/// @ref gtx_euler_angles
2/// @file glm/gtx/euler_angles.hpp
3///
4/// @see core (dependence)
5///
6/// @defgroup gtx_euler_angles GLM_GTX_euler_angles
7/// @ingroup gtx
8///
9/// Include <glm/gtx/euler_angles.hpp> to use the features of this extension.
10///
11/// Build matrices from Euler angles.
12///
13/// Extraction of Euler angles from rotation matrix.
14/// Based on the original paper 2014 Mike Day - Extracting Euler Angles from a Rotation Matrix.
15
16#pragma once
17
18// Dependency:
19#include "../glm.hpp"
20
21#ifndef GLM_ENABLE_EXPERIMENTAL
22# error "GLM: GLM_GTX_euler_angles is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
23#elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
24# pragma message("GLM: GLM_GTX_euler_angles extension included")
25#endif
26
27namespace glm
28{
29 /// @addtogroup gtx_euler_angles
30 /// @{
31
32 /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
33 /// @see gtx_euler_angles
34 template<typename T>
35 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX(
36 T const& angleX);
37
38 /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
39 /// @see gtx_euler_angles
40 template<typename T>
41 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY(
42 T const& angleY);
43
44 /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
45 /// @see gtx_euler_angles
46 template<typename T>
47 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ(
48 T const& angleZ);
49
50 /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about X-axis.
51 /// @see gtx_euler_angles
52 template <typename T>
53 GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleX(
54 T const & angleX, T const & angularVelocityX);
55
56 /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Y-axis.
57 /// @see gtx_euler_angles
58 template <typename T>
59 GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleY(
60 T const & angleY, T const & angularVelocityY);
61
62 /// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Z-axis.
63 /// @see gtx_euler_angles
64 template <typename T>
65 GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleZ(
66 T const & angleZ, T const & angularVelocityZ);
67
68 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
69 /// @see gtx_euler_angles
70 template<typename T>
71 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY(
72 T const& angleX,
73 T const& angleY);
74
75 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
76 /// @see gtx_euler_angles
77 template<typename T>
78 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX(
79 T const& angleY,
80 T const& angleX);
81
82 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
83 /// @see gtx_euler_angles
84 template<typename T>
85 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ(
86 T const& angleX,
87 T const& angleZ);
88
89 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
90 /// @see gtx_euler_angles
91 template<typename T>
92 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX(
93 T const& angle,
94 T const& angleX);
95
96 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
97 /// @see gtx_euler_angles
98 template<typename T>
99 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ(
100 T const& angleY,
101 T const& angleZ);
102
103 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
104 /// @see gtx_euler_angles
105 template<typename T>
106 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY(
107 T const& angleZ,
108 T const& angleY);
109
110 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).
111 /// @see gtx_euler_angles
112 template<typename T>
113 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ(
114 T const& t1,
115 T const& t2,
116 T const& t3);
117
118 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
119 /// @see gtx_euler_angles
120 template<typename T>
121 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ(
122 T const& yaw,
123 T const& pitch,
124 T const& roll);
125
126 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * X).
127 /// @see gtx_euler_angles
128 template <typename T>
129 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZX(
130 T const & t1,
131 T const & t2,
132 T const & t3);
133
134 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * X).
135 /// @see gtx_euler_angles
136 template <typename T>
137 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYX(
138 T const & t1,
139 T const & t2,
140 T const & t3);
141
142 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Y).
143 /// @see gtx_euler_angles
144 template <typename T>
145 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXY(
146 T const & t1,
147 T const & t2,
148 T const & t3);
149
150 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * Y).
151 /// @see gtx_euler_angles
152 template <typename T>
153 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZY(
154 T const & t1,
155 T const & t2,
156 T const & t3);
157
158 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * Z).
159 /// @see gtx_euler_angles
160 template <typename T>
161 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYZ(
162 T const & t1,
163 T const & t2,
164 T const & t3);
165
166 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Z).
167 /// @see gtx_euler_angles
168 template <typename T>
169 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXZ(
170 T const & t1,
171 T const & t2,
172 T const & t3);
173
174 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * Y).
175 /// @see gtx_euler_angles
176 template <typename T>
177 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZY(
178 T const & t1,
179 T const & t2,
180 T const & t3);
181
182 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * X).
183 /// @see gtx_euler_angles
184 template <typename T>
185 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZX(
186 T const & t1,
187 T const & t2,
188 T const & t3);
189
190 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * X).
191 /// @see gtx_euler_angles
192 template <typename T>
193 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYX(
194 T const & t1,
195 T const & t2,
196 T const & t3);
197
198 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Y).
199 /// @see gtx_euler_angles
200 template <typename T>
201 GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXY(
202 T const & t1,
203 T const & t2,
204 T const & t3);
205
206 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
207 /// @see gtx_euler_angles
208 template<typename T>
209 GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll(
210 T const& yaw,
211 T const& pitch,
212 T const& roll);
213
214 /// Creates a 2D 2 * 2 rotation matrix from an euler angle.
215 /// @see gtx_euler_angles
216 template<typename T>
217 GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const& angle);
218
219 /// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
220 /// @see gtx_euler_angles
221 template<typename T>
222 GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const& angle);
223
224 /// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
225 /// @see gtx_euler_angles
226 template<typename T, qualifier Q>
227 GLM_FUNC_DECL mat<3, 3, T, Q> orientate3(vec<3, T, Q> const& angles);
228
229 /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
230 /// @see gtx_euler_angles
231 template<typename T, qualifier Q>
232 GLM_FUNC_DECL mat<4, 4, T, Q> orientate4(vec<3, T, Q> const& angles);
233
234 /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M
235 /// @see gtx_euler_angles
236 template<typename T>
237 GLM_FUNC_DISCARD_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M,
238 T & t1,
239 T & t2,
240 T & t3);
241
242 /// Extracts the (Y * X * Z) Euler angles from the rotation matrix M
243 /// @see gtx_euler_angles
244 template <typename T>
245 GLM_FUNC_DISCARD_DECL void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M,
246 T & t1,
247 T & t2,
248 T & t3);
249
250 /// Extracts the (X * Z * X) Euler angles from the rotation matrix M
251 /// @see gtx_euler_angles
252 template <typename T>
253 GLM_FUNC_DISCARD_DECL void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M,
254 T & t1,
255 T & t2,
256 T & t3);
257
258 /// Extracts the (X * Y * X) Euler angles from the rotation matrix M
259 /// @see gtx_euler_angles
260 template <typename T>
261 GLM_FUNC_DISCARD_DECL void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M,
262 T & t1,
263 T & t2,
264 T & t3);
265
266 /// Extracts the (Y * X * Y) Euler angles from the rotation matrix M
267 /// @see gtx_euler_angles
268 template <typename T>
269 GLM_FUNC_DISCARD_DECL void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M,
270 T & t1,
271 T & t2,
272 T & t3);
273
274 /// Extracts the (Y * Z * Y) Euler angles from the rotation matrix M
275 /// @see gtx_euler_angles
276 template <typename T>
277 GLM_FUNC_DISCARD_DECL void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M,
278 T & t1,
279 T & t2,
280 T & t3);
281
282 /// Extracts the (Z * Y * Z) Euler angles from the rotation matrix M
283 /// @see gtx_euler_angles
284 template <typename T>
285 GLM_FUNC_DISCARD_DECL void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M,
286 T & t1,
287 T & t2,
288 T & t3);
289
290 /// Extracts the (Z * X * Z) Euler angles from the rotation matrix M
291 /// @see gtx_euler_angles
292 template <typename T>
293 GLM_FUNC_DISCARD_DECL void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M,
294 T & t1,
295 T & t2,
296 T & t3);
297
298 /// Extracts the (X * Z * Y) Euler angles from the rotation matrix M
299 /// @see gtx_euler_angles
300 template <typename T>
301 GLM_FUNC_DISCARD_DECL void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M,
302 T & t1,
303 T & t2,
304 T & t3);
305
306 /// Extracts the (Y * Z * X) Euler angles from the rotation matrix M
307 /// @see gtx_euler_angles
308 template <typename T>
309 GLM_FUNC_DISCARD_DECL void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M,
310 T & t1,
311 T & t2,
312 T & t3);
313
314 /// Extracts the (Z * Y * X) Euler angles from the rotation matrix M
315 /// @see gtx_euler_angles
316 template <typename T>
317 GLM_FUNC_DISCARD_DECL void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M,
318 T & t1,
319 T & t2,
320 T & t3);
321
322 /// Extracts the (Z * X * Y) Euler angles from the rotation matrix M
323 /// @see gtx_euler_angles
324 template <typename T>
325 GLM_FUNC_DISCARD_DECL void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M,
326 T & t1,
327 T & t2,
328 T & t3);
329
330 /// @}
331}//namespace glm
332
333#include "euler_angles.inl"