BLI_math_rotation: properly name the quaternion power function.
[blender.git] / source / blender / blenlib / BLI_math_rotation.h
index 50f4a034d40f371bc1b9ec061ef2395421130830..2bc82bac8d8f83d728530d2aed807bc009b1362f 100644 (file)
@@ -1,6 +1,4 @@
 /*
- * $Id$
- *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -25,8 +23,8 @@
  * ***** END GPL LICENSE BLOCK *****
  * */
 
-#ifndef BLI_MATH_ROTATION_H
-#define BLI_MATH_ROTATION_H
+#ifndef __BLI_MATH_ROTATION_H__
+#define __BLI_MATH_ROTATION_H__
 
 /** \file BLI_math_rotation.h
  *  \ingroup bli
 extern "C" {
 #endif
 
-#define RAD2DEG(_rad) ((_rad)*(180.0/M_PI))
-#define DEG2RAD(_deg) ((_deg)*(M_PI/180.0))
+#define RAD2DEG(_rad) ((_rad) * (180.0 / M_PI))
+#define DEG2RAD(_deg) ((_deg) * (M_PI / 180.0))
 
 
-#define RAD2DEGF(_rad) ((_rad)*(float)(180.0/M_PI))
-#define DEG2RADF(_deg) ((_deg)*(float)(M_PI/180.0))
+#define RAD2DEGF(_rad) ((_rad) * (float)(180.0 / M_PI))
+#define DEG2RADF(_deg) ((_deg) * (float)(M_PI / 180.0))
 
 /******************************** Quaternions ********************************/
 /* stored in (w, x, y, z) order                                              */
@@ -55,21 +53,26 @@ void copy_qt_qt(float q[4], const float a[4]);
 void mul_qt_qtqt(float q[4], const float a[4], const float b[4]);
 void mul_qt_v3(const float q[4], float r[3]);
 void mul_qt_fl(float q[4], const float f);
-void mul_fac_qt_fl(float q[4], const float f);
+
+void pow_qt_fl_normalized(float q[4], const float f);
 
 void sub_qt_qtqt(float q[4], const float a[4], const float b[4]);
 
 void invert_qt(float q[4]);
 void invert_qt_qt(float q1[4], const float q2[4]);
+void invert_qt_normalized(float q[4]);
+void invert_qt_qt_normalized(float q1[4], const float q2[4]);
 void conjugate_qt(float q[4]);
+void conjugate_qt_qt(float q1[4], const float q2[4]);
 float dot_qtqt(const float a[4], const float b[4]);
 float normalize_qt(float q[4]);
 float normalize_qt_qt(float q1[4], const float q2[4]);
 
 /* comparison */
-int is_zero_qt(float q[4]);
+bool is_zero_qt(const float q[4]);
 
 /* interpolation */
+void interp_dot_slerp(const float t, const float cosom, float w[2]);
 void interp_qt_qtqt(float q[4], const float a[4], const float b[4], const float t);
 void add_qt_qtqt(float q[4], const float a[4], const float b[4], const float t);
 
@@ -77,41 +80,64 @@ void add_qt_qtqt(float q[4], const float a[4], const float b[4], const float t);
 void quat_to_mat3(float mat[3][3], const float q[4]);
 void quat_to_mat4(float mat[4][4], const float q[4]);
 
+void mat3_normalized_to_quat(float q[4], float mat[3][3]);
+void mat4_normalized_to_quat(float q[4], float mat[4][4]);
 void mat3_to_quat(float q[4], float mat[3][3]);
 void mat4_to_quat(float q[4], float mat[4][4]);
-void tri_to_quat(float q[4], const float a[3], const float b[3], const float c[3]);
-void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag);
+void tri_to_quat_ex(float quat[4], const float v1[3], const float v2[3], const float v3[3],
+                    const float no_orig[3]);
+float tri_to_quat(float q[4], const float a[3], const float b[3], const float c[3]);
+void  vec_to_quat(float q[4], const float vec[3], short axis, const short upflag);
 /* note: v1 and v2 must be normalized */
+void rotation_between_vecs_to_mat3(float m[3][3], const float v1[3], const float v2[3]);
 void rotation_between_vecs_to_quat(float q[4], const float v1[3], const float v2[3]);
 void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q2[4]);
 
+float angle_normalized_qt(const float q[4]);
+float angle_normalized_qtqt(const float q1[4], const float q2[4]);
+float angle_qt(const float q[4]);
+float angle_qtqt(const float q1[4], const float q2[4]);
+
+float angle_signed_normalized_qt(const float q[4]);
+float angle_signed_normalized_qtqt(const float q1[4], const float q2[4]);
+float angle_signed_qt(const float q[4]);
+float angle_signed_qtqt(const float q1[4], const float q2[4]);
+
 /* TODO: don't what this is, but it's not the same as mat3_to_quat */
 void mat3_to_quat_is_ok(float q[4], float mat[3][3]);
 
 /* other */
 void print_qt(const char *str, const float q[4]);
 
+#define print_qt_id(q) print_qt(STRINGIFY(q), q)
+
 /******************************** Axis Angle *********************************/
 
 /* conversion */
-void axis_angle_to_quat(float r[4], const float axis[3], float angle);
+void axis_angle_normalized_to_quat(float r[4], const float axis[3], const float angle);
+void axis_angle_to_quat(float r[4], const float axis[3], const float angle);
 void axis_angle_to_mat3(float R[3][3], const float axis[3], const float angle);
+void axis_angle_normalized_to_mat3_ex(float mat[3][3], const float axis[3],
+                                      const float angle_sin, const float angle_cos);
+void axis_angle_normalized_to_mat3(float R[3][3], const float axis[3], const float angle);
 void axis_angle_to_mat4(float R[4][4], const float axis[3], const float angle);
 
-void quat_to_axis_angle(float axis[3], float *angle, const float q[4]);
+void mat3_normalized_to_axis_angle(float axis[3], float *angle, float M[3][3]);
+void mat4_normalized_to_axis_angle(float axis[3], float *angle, float M[4][4]);
 void mat3_to_axis_angle(float axis[3], float *angle, float M[3][3]);
 void mat4_to_axis_angle(float axis[3], float *angle, float M[4][4]);
+void quat_to_axis_angle(float axis[3], float *angle, const float q[4]);
 
-void single_axis_angle_to_mat3(float R[3][3], const char axis, const float angle);
+void      angle_to_mat2(float R[2][2], const float angle);
+void axis_angle_to_mat3_single(float R[3][3], const char axis, const float angle);
+void axis_angle_to_mat4_single(float R[4][4], const char axis, const float angle);
 
-/****************************** Vector/Rotation ******************************/
-/* old axis angle code                                                       */
-/* TODO: the following calls should probably be depreceated sometime         */
+void axis_angle_to_quat_single(float q[4], const char axis, const float angle);
 
-/* conversion */
-void vec_rot_to_quat(float quat[4], const float vec[3], const float phi);
-void vec_rot_to_mat3(float mat[3][3], const float vec[3], const float phi);
-void vec_rot_to_mat4(float mat[4][4], const float vec[3], const float phi);
+/****************************** Exponential Map ******************************/
+void quat_to_expmap(float expmap[3], const float q[4]);
+void quat_normalized_to_expmap(float expmap[3], const float q[4]);
+void expmap_to_quat(float r[4], const float expmap[3]);
 
 /******************************** XYZ Eulers *********************************/
 
@@ -119,12 +145,16 @@ void eul_to_quat(float quat[4], const float eul[3]);
 void eul_to_mat3(float mat[3][3], const float eul[3]);
 void eul_to_mat4(float mat[4][4], const float eul[3]);
 
-void quat_to_eul(float eul[3], const float quat[4]);
+void mat3_normalized_to_eul(float eul[3], float mat[3][3]);
+void mat4_normalized_to_eul(float eul[3], float mat[4][4]);
 void mat3_to_eul(float eul[3], float mat[3][3]);
 void mat4_to_eul(float eul[3], float mat[4][4]);
+void quat_to_eul(float eul[3], const float quat[4]);
 
-void compatible_eul(float eul[3], const float old[3]);
+void mat3_normalized_to_compatible_eul(float eul[3], const float old[3], float mat[3][3]);
 void mat3_to_compatible_eul(float eul[3], const float old[3], float mat[3][3]);
+void quat_to_compatible_eul(float eul[3], const float oldrot[3], const float quat[4]);
+void compatible_eul(float eul[3], const float old[3]);
 
 void rotate_eul(float eul[3], const char axis, const float angle);
 
@@ -149,16 +179,21 @@ void eulO_to_mat3(float mat[3][3], const float eul[3], const short order);
 void eulO_to_mat4(float mat[4][4], const float eul[3], const short order);
 void eulO_to_axis_angle(float axis[3], float *angle, const float eul[3], const short order);
 void eulO_to_gimbal_axis(float gmat[3][3], const float eul[3], const short order);
-void quat_to_eulO(float eul[3], const short order, const float quat[4]);
+
+void mat3_normalized_to_eulO(float eul[3], const short order, float mat[3][3]);
+void mat4_normalized_to_eulO(float eul[3], const short order, float mat[4][4]);
 void mat3_to_eulO(float eul[3], const short order, float mat[3][3]);
 void mat4_to_eulO(float eul[3], const short order, float mat[4][4]);
+void quat_to_eulO(float eul[3], const short order, const float quat[4]);
 void axis_angle_to_eulO(float eul[3], const short order, const float axis[3], const float angle);
 
-void mat3_to_compatible_eulO(float eul[3], float old[3], short order, float mat[3][3]);
-void mat4_to_compatible_eulO(float eul[3], float old[3], short order, float mat[4][4]);
+void mat3_normalized_to_compatible_eulO(float eul[3], float old[3], const short order, float mat[3][3]);
+void mat4_normalized_to_compatible_eulO(float eul[3], float old[3], const short order, float mat[4][4]);
+void mat3_to_compatible_eulO(float eul[3], float old[3], const short order, float mat[3][3]);
+void mat4_to_compatible_eulO(float eul[3], float old[3], const short order, float mat[4][4]);
+void quat_to_compatible_eulO(float eul[3], float old[3], const short order, const float quat[4]);
 
-void rotate_eulO(float eul[3], short order, char axis, float angle);
+void rotate_eulO(float eul[3], const short order, char axis, float angle);
 
 /******************************* Dual Quaternions ****************************/
 
@@ -170,26 +205,34 @@ typedef struct DualQuat {
        float scale_weight;
 } DualQuat;
 
-void copy_dq_dq(DualQuat *r, DualQuat *dq);
+void copy_dq_dq(DualQuat *r, const DualQuat *dq);
 void normalize_dq(DualQuat *dq, float totw);
-void add_weighted_dq_dq(DualQuat *r, DualQuat *dq, float weight);
+void add_weighted_dq_dq(DualQuat *r, const DualQuat *dq, float weight);
 void mul_v3m3_dq(float r[3], float R[3][3], DualQuat *dq);
 
 void mat4_to_dquat(DualQuat *r, float base[4][4], float M[4][4]);
-void dquat_to_mat4(float R[4][4], DualQuat *dq);
+void dquat_to_mat4(float R[4][4], const DualQuat *dq);
 
 void quat_apply_track(float quat[4], short axis, short upflag);
 void vec_apply_track(float vec[3], short axis);
 
-float focallength_to_hfov(float focal_length, float sensor_x);
-float hfov_to_focallength(float hfov, float sensor_x);
+float focallength_to_fov(float focal_length, float sensor);
+float fov_to_focallength(float fov, float sensor);
 
 float angle_wrap_rad(float angle);
 float angle_wrap_deg(float angle);
 
+float angle_compat_rad(float angle, float angle_compat);
+
+bool mat3_from_axis_conversion(
+        int src_forward, int src_up, int dst_forward, int dst_up,
+        float r_mat[3][3]);
+bool mat3_from_axis_conversion_single(
+        int src_axis, int dst_axis,
+        float r_mat[3][3]);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* BLI_MATH_ROTATION_H */
-
+#endif /* __BLI_MATH_ROTATION_H__ */