ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenlib / BLI_math_rotation.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  *
19  * The Original Code is: some of this file.
20  *
21  * */
22
23 #ifndef __BLI_MATH_ROTATION_H__
24 #define __BLI_MATH_ROTATION_H__
25
26 /** \file
27  * \ingroup bli
28  */
29
30 #ifdef __cplusplus
31 extern "C" {
32 #endif
33
34 #define RAD2DEG(_rad) ((_rad) * (180.0 / M_PI))
35 #define DEG2RAD(_deg) ((_deg) * (M_PI / 180.0))
36
37 #define RAD2DEGF(_rad) ((_rad) * (float)(180.0 / M_PI))
38 #define DEG2RADF(_deg) ((_deg) * (float)(M_PI / 180.0))
39
40 /******************************** Quaternions ********************************/
41 /* stored in (w, x, y, z) order                                              */
42
43 /* init */
44 void unit_axis_angle(float axis[3], float *angle);
45 void unit_qt(float q[4]);
46 void copy_qt_qt(float q[4], const float a[4]);
47
48 /* arithmetic */
49 void mul_qt_qtqt(float q[4], const float a[4], const float b[4]);
50 void mul_qt_v3(const float q[4], float r[3]);
51 void mul_qt_fl(float q[4], const float f);
52
53 void pow_qt_fl_normalized(float q[4], const float f);
54
55 void sub_qt_qtqt(float q[4], const float a[4], const float b[4]);
56
57 void invert_qt(float q[4]);
58 void invert_qt_qt(float q1[4], const float q2[4]);
59 void invert_qt_normalized(float q[4]);
60 void invert_qt_qt_normalized(float q1[4], const float q2[4]);
61 void conjugate_qt(float q[4]);
62 void conjugate_qt_qt(float q1[4], const float q2[4]);
63 float dot_qtqt(const float a[4], const float b[4]);
64 float normalize_qt(float q[4]);
65 float normalize_qt_qt(float q1[4], const float q2[4]);
66
67 /* comparison */
68 bool is_zero_qt(const float q[4]);
69
70 /* interpolation */
71 void interp_dot_slerp(const float t, const float cosom, float w[2]);
72 void interp_qt_qtqt(float q[4], const float a[4], const float b[4], const float t);
73 void add_qt_qtqt(float q[4], const float a[4], const float b[4], const float t);
74
75 /* conversion */
76 void quat_to_mat3(float mat[3][3], const float q[4]);
77 void quat_to_mat4(float mat[4][4], const float q[4]);
78
79 void quat_to_compatible_quat(float q[4], const float a[4], const float old[4]);
80
81 void mat3_normalized_to_quat(float q[4], const float mat[3][3]);
82 void mat4_normalized_to_quat(float q[4], const float mat[4][4]);
83 void mat3_to_quat(float q[4], const float mat[3][3]);
84 void mat4_to_quat(float q[4], const float mat[4][4]);
85 void tri_to_quat_ex(float quat[4],
86                     const float v1[3],
87                     const float v2[3],
88                     const float v3[3],
89                     const float no_orig[3]);
90 float tri_to_quat(float q[4], const float a[3], const float b[3], const float c[3]);
91 void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag);
92 /* note: v1 and v2 must be normalized */
93 void rotation_between_vecs_to_mat3(float m[3][3], const float v1[3], const float v2[3]);
94 void rotation_between_vecs_to_quat(float q[4], const float v1[3], const float v2[3]);
95 void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q2[4]);
96
97 float angle_normalized_qt(const float q[4]);
98 float angle_normalized_qtqt(const float q1[4], const float q2[4]);
99 float angle_qt(const float q[4]);
100 float angle_qtqt(const float q1[4], const float q2[4]);
101
102 float angle_signed_normalized_qt(const float q[4]);
103 float angle_signed_normalized_qtqt(const float q1[4], const float q2[4]);
104 float angle_signed_qt(const float q[4]);
105 float angle_signed_qtqt(const float q1[4], const float q2[4]);
106
107 /* TODO: don't what this is, but it's not the same as mat3_to_quat */
108 void mat3_to_quat_is_ok(float q[4], const float mat[3][3]);
109
110 /* other */
111 void print_qt(const char *str, const float q[4]);
112
113 #define print_qt_id(q) print_qt(STRINGIFY(q), q)
114
115 /******************************** Axis Angle *********************************/
116
117 /* conversion */
118 void axis_angle_normalized_to_quat(float r[4], const float axis[3], const float angle);
119 void axis_angle_to_quat(float r[4], const float axis[3], const float angle);
120 void axis_angle_to_mat3(float R[3][3], const float axis[3], const float angle);
121 void axis_angle_normalized_to_mat3_ex(float mat[3][3],
122                                       const float axis[3],
123                                       const float angle_sin,
124                                       const float angle_cos);
125 void axis_angle_normalized_to_mat3(float R[3][3], const float axis[3], const float angle);
126 void axis_angle_to_mat4(float R[4][4], const float axis[3], const float angle);
127
128 void mat3_normalized_to_axis_angle(float axis[3], float *angle, const float M[3][3]);
129 void mat4_normalized_to_axis_angle(float axis[3], float *angle, const float M[4][4]);
130 void mat3_to_axis_angle(float axis[3], float *angle, const float M[3][3]);
131 void mat4_to_axis_angle(float axis[3], float *angle, const float M[4][4]);
132 void quat_to_axis_angle(float axis[3], float *angle, const float q[4]);
133
134 void angle_to_mat2(float R[2][2], const float angle);
135 void axis_angle_to_mat3_single(float R[3][3], const char axis, const float angle);
136 void axis_angle_to_mat4_single(float R[4][4], const char axis, const float angle);
137
138 void axis_angle_to_quat_single(float q[4], const char axis, const float angle);
139
140 /****************************** Exponential Map ******************************/
141 void quat_to_expmap(float expmap[3], const float q[4]);
142 void quat_normalized_to_expmap(float expmap[3], const float q[4]);
143 void expmap_to_quat(float r[4], const float expmap[3]);
144
145 /******************************** XYZ Eulers *********************************/
146
147 void eul_to_quat(float quat[4], const float eul[3]);
148 void eul_to_mat3(float mat[3][3], const float eul[3]);
149 void eul_to_mat4(float mat[4][4], const float eul[3]);
150
151 void mat3_normalized_to_eul(float eul[3], const float mat[3][3]);
152 void mat4_normalized_to_eul(float eul[3], const float mat[4][4]);
153 void mat3_to_eul(float eul[3], const float mat[3][3]);
154 void mat4_to_eul(float eul[3], const float mat[4][4]);
155 void quat_to_eul(float eul[3], const float quat[4]);
156
157 void mat3_normalized_to_compatible_eul(float eul[3], const float old[3], float mat[3][3]);
158 void mat3_to_compatible_eul(float eul[3], const float old[3], float mat[3][3]);
159 void quat_to_compatible_eul(float eul[3], const float oldrot[3], const float quat[4]);
160 void compatible_eul(float eul[3], const float old[3]);
161
162 void rotate_eul(float eul[3], const char axis, const float angle);
163
164 /************************** Arbitrary Order Eulers ***************************/
165
166 /* warning: must match the eRotationModes in DNA_action_types.h
167  * order matters - types are saved to file. */
168
169 typedef enum eEulerRotationOrders {
170   EULER_ORDER_DEFAULT = 1, /* blender classic = XYZ */
171   EULER_ORDER_XYZ = 1,
172   EULER_ORDER_XZY,
173   EULER_ORDER_YXZ,
174   EULER_ORDER_YZX,
175   EULER_ORDER_ZXY,
176   EULER_ORDER_ZYX,
177   /* there are 6 more entries with dulpicate entries included */
178 } eEulerRotationOrders;
179
180 void eulO_to_quat(float quat[4], const float eul[3], const short order);
181 void eulO_to_mat3(float mat[3][3], const float eul[3], const short order);
182 void eulO_to_mat4(float mat[4][4], const float eul[3], const short order);
183 void eulO_to_axis_angle(float axis[3], float *angle, const float eul[3], const short order);
184 void eulO_to_gimbal_axis(float gmat[3][3], const float eul[3], const short order);
185
186 void mat3_normalized_to_eulO(float eul[3], const short order, const float mat[3][3]);
187 void mat4_normalized_to_eulO(float eul[3], const short order, const float mat[4][4]);
188 void mat3_to_eulO(float eul[3], const short order, const float mat[3][3]);
189 void mat4_to_eulO(float eul[3], const short order, const float mat[4][4]);
190 void quat_to_eulO(float eul[3], const short order, const float quat[4]);
191 void axis_angle_to_eulO(float eul[3], const short order, const float axis[3], const float angle);
192
193 void mat3_normalized_to_compatible_eulO(float eul[3],
194                                         const float old[3],
195                                         const short order,
196                                         const float mat[3][3]);
197 void mat4_normalized_to_compatible_eulO(float eul[3],
198                                         const float old[3],
199                                         const short order,
200                                         const float mat[4][4]);
201 void mat3_to_compatible_eulO(float eul[3],
202                              const float old[3],
203                              const short order,
204                              const float mat[3][3]);
205 void mat4_to_compatible_eulO(float eul[3],
206                              const float old[3],
207                              const short order,
208                              const float mat[4][4]);
209 void quat_to_compatible_eulO(float eul[3],
210                              const float old[3],
211                              const short order,
212                              const float quat[4]);
213
214 void rotate_eulO(float eul[3], const short order, char axis, float angle);
215
216 /******************************* Dual Quaternions ****************************/
217
218 typedef struct DualQuat {
219   float quat[4];
220   float trans[4];
221
222   float scale[4][4];
223   float scale_weight;
224 } DualQuat;
225
226 void copy_dq_dq(DualQuat *r, const DualQuat *dq);
227 void normalize_dq(DualQuat *dq, float totw);
228 void add_weighted_dq_dq(DualQuat *r, const DualQuat *dq, float weight);
229 void mul_v3m3_dq(float r[3], float R[3][3], DualQuat *dq);
230
231 void mat4_to_dquat(DualQuat *r, const float base[4][4], const float M[4][4]);
232 void dquat_to_mat4(float R[4][4], const DualQuat *dq);
233
234 void quat_apply_track(float quat[4], short axis, short upflag);
235 void vec_apply_track(float vec[3], short axis);
236
237 float focallength_to_fov(float focal_length, float sensor);
238 float fov_to_focallength(float fov, float sensor);
239
240 float angle_wrap_rad(float angle);
241 float angle_wrap_deg(float angle);
242
243 float angle_compat_rad(float angle, float angle_compat);
244
245 bool mat3_from_axis_conversion(
246     int src_forward, int src_up, int dst_forward, int dst_up, float r_mat[3][3]);
247 bool mat3_from_axis_conversion_single(int src_axis, int dst_axis, float r_mat[3][3]);
248
249 #ifdef __cplusplus
250 }
251 #endif
252
253 #endif /* __BLI_MATH_ROTATION_H__ */