changes to path searching
[blender.git] / source / blender / blenlib / BLI_math_rotation.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: some of this file.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  * */
27
28 #ifndef BLI_MATH_ROTATION
29 #define BLI_MATH_ROTATION
30
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34
35 #define RAD2DEG(_rad) ((_rad)*(180.0/M_PI))
36 #define DEG2RAD(_deg) ((_deg)*(M_PI/180.0))
37
38 /******************************** Quaternions ********************************/
39 /* stored in (w, x, y, z) order                                              */
40
41 /* init */
42 void unit_qt(float q[4]);
43 void copy_qt_qt(float q[4], const float a[4]);
44
45 /* arithmetic */
46 void mul_qt_qtqt(float q[4], const float a[4], const float b[4]);
47 void mul_qt_v3(const float q[4], float r[3]);
48 void mul_qt_fl(float q[4], const float f);
49 void mul_fac_qt_fl(float q[4], const float f);
50
51 void sub_qt_qtqt(float q[4], float a[4], float b[4]);
52
53 void invert_qt(float q[4]);
54 void invert_qt_qt(float *q1, const float *q2);
55 void conjugate_qt(float q[4]);
56 float dot_qtqt(float a[4], float b[4]);
57 void normalize_qt(float q[4]);
58
59 /* comparison */
60 int is_zero_qt(float q[4]);
61
62 /* interpolation */
63 void interp_qt_qtqt(float q[4], float a[4], float b[4], float t);
64 void add_qt_qtqt(float q[4], float a[4], float b[4], float t);
65
66 /* conversion */
67 void quat_to_mat3(float mat[3][3], float q[4]);
68 void quat_to_mat4(float mat[4][4], float q[4]);
69
70 void mat3_to_quat(float q[4], float mat[3][3]);
71 void mat4_to_quat(float q[4], float mat[4][4]);
72 void tri_to_quat(float q[4], float a[3], float b[3], float c[3]);
73 void vec_to_quat(float q[4], float vec[3], short axis, short upflag);
74 /* note: v1 and v2 must be normalized */
75 void rotation_between_vecs_to_quat(float q[4], const float v1[3], const float v2[3]);
76 void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q2[4]);
77
78 /* TODO: don't what this is, but it's not the same as mat3_to_quat */
79 void mat3_to_quat_is_ok(float q[4], float mat[3][3]);
80
81 /* other */
82 void print_qt(char *str, float q[4]);
83
84 /******************************** Axis Angle *********************************/
85
86 /* conversion */
87 void axis_angle_to_quat(float r[4], float axis[3], float angle);
88 void axis_angle_to_mat3(float R[3][3], float axis[3], float angle);
89 void axis_angle_to_mat4(float R[4][4], float axis[3], float angle);
90
91 void quat_to_axis_angle(float axis[3], float *angle, float q[4]);
92 void mat3_to_axis_angle(float axis[3], float *angle, float M[3][3]);
93 void mat4_to_axis_angle(float axis[3], float *angle, float M[4][4]);
94
95 /****************************** Vector/Rotation ******************************/
96 /* old axis angle code                                                       */
97 /* TODO: the following calls should probably be depreceated sometime         */
98
99 /* conversion */
100 void mat3_to_vec_rot(float vec[3], float *phi, float mat[3][3]);
101 void mat4_to_vec_rot(float vec[3], float *phi, float mat[4][4]);
102
103 void vec_rot_to_quat(float quat[4], float vec[3], float phi);
104 void vec_rot_to_mat3(float mat[3][3], float vec[3], float phi);
105 void vec_rot_to_mat4(float mat[4][4], float vec[3], float phi);
106
107 /******************************** XYZ Eulers *********************************/
108
109 void eul_to_quat(float quat[4], float eul[3]);
110 void eul_to_mat3(float mat[3][3], float eul[3]);
111 void eul_to_mat4(float mat[4][4], float eul[3]);
112
113 void quat_to_eul(float eul[3], float quat[4]);
114 void mat3_to_eul(float eul[3], float mat[3][3]);
115 void mat4_to_eul(float eul[3], float mat[4][4]);
116
117 void compatible_eul(float eul[3], float old[3]);
118 void mat3_to_compatible_eul(float eul[3], float old[3], float mat[3][3]);
119
120 void rotate_eul(float eul[3], char axis, float angle);
121
122 /************************** Arbitrary Order Eulers ***************************/
123
124 /* warning: must match the eRotationModes in DNA_action_types.h
125  * order matters - types are saved to file. */
126
127 typedef enum eEulerRotationOrders {
128         EULER_ORDER_DEFAULT = 1, /* blender classic = XYZ */
129         EULER_ORDER_XYZ = 1,
130         EULER_ORDER_XZY,
131         EULER_ORDER_YXZ,
132         EULER_ORDER_YZX,
133         EULER_ORDER_ZXY,
134         EULER_ORDER_ZYX,
135         /* there are 6 more entries with dulpicate entries included */
136 } eEulerRotationOrders;
137
138 void eulO_to_quat(float quat[4], float eul[3], short order);
139 void eulO_to_mat3(float mat[3][3], float eul[3], short order);
140 void eulO_to_mat4(float mat[4][4], float eul[3], short order);
141 void eulO_to_axis_angle(float axis[3], float *angle, float eul[3], short order);
142 void eulO_to_gimbal_axis(float gmat[3][3], float eul[3], short order);
143  
144 void quat_to_eulO(float eul[3], short order, float quat[4]);
145 void mat3_to_eulO(float eul[3], short order, float mat[3][3]);
146 void mat4_to_eulO(float eul[3], short order, float mat[4][4]);
147 void axis_angle_to_eulO(float eul[3], short order, float axis[3], float angle);
148
149 void mat3_to_compatible_eulO(float eul[3], float old[3], short order, float mat[3][3]);
150 void mat4_to_compatible_eulO(float eul[3], float old[3], short order, float mat[4][4]);
151
152 void rotate_eulO(float eul[3], short order, char axis, float angle);
153
154 /******************************* Dual Quaternions ****************************/
155
156 typedef struct DualQuat {
157         float quat[4];
158         float trans[4];
159
160         float scale[4][4];
161         float scale_weight;
162 } DualQuat;
163
164 void copy_dq_dq(DualQuat *r, DualQuat *dq);
165 void normalize_dq(DualQuat *dq, float totw);
166 void add_weighted_dq_dq(DualQuat *r, DualQuat *dq, float weight);
167 void mul_v3m3_dq(float r[3], float R[3][3], DualQuat *dq);
168
169 void mat4_to_dquat(DualQuat *r, float base[4][4], float M[4][4]);
170 void dquat_to_mat4(float R[4][4], DualQuat *dq);
171
172 float lens_to_angle(float lens);
173 float angle_to_lens(float angle);
174
175 #ifdef __cplusplus
176 }
177 #endif
178
179 #endif /* BLI_MATH_ROTATION */
180