Cleanup: match names between functions & declarations
Mostly update the declarations, in some cases rename in the function especially when the names used were inconstant with related functions.
This commit is contained in:
parent
5bd1d63115
commit
b04514da5d
|
|
@ -164,7 +164,9 @@ void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4]);
|
|||
MINLINE float rgb_to_grayscale(const float rgb[3]);
|
||||
MINLINE unsigned char rgb_to_grayscale_byte(const unsigned char rgb[3]);
|
||||
|
||||
MINLINE int compare_rgb_uchar(const unsigned char a[3], const unsigned char b[3], int limit);
|
||||
MINLINE int compare_rgb_uchar(const unsigned char col_a[3],
|
||||
const unsigned char col_b[3],
|
||||
int limit);
|
||||
|
||||
/**
|
||||
* Return triangle noise in [-0.5..1.5] range.
|
||||
|
|
|
|||
|
|
@ -1270,8 +1270,8 @@ MINLINE void mul_sh_fl(float r[9], float f);
|
|||
MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9]);
|
||||
MINLINE float dot_shsh(const float a[9], const float b[9]);
|
||||
|
||||
MINLINE float eval_shv3(float r[9], const float v[3]);
|
||||
MINLINE float diffuse_shv3(const float r[9], const float v[3]);
|
||||
MINLINE float eval_shv3(float sh[9], const float v[3]);
|
||||
MINLINE float diffuse_shv3(const float sh[9], const float v[3]);
|
||||
MINLINE void vec_fac_to_sh(float r[9], const float v[3], float f);
|
||||
MINLINE void madd_sh_shfl(float r[9], const float sh[9], float f);
|
||||
|
||||
|
|
|
|||
|
|
@ -98,110 +98,110 @@ void mul_m4_m4_post(float R[4][4], const float B[4][4]);
|
|||
|
||||
/* Implement #mul_m3_series macro. */
|
||||
|
||||
void _va_mul_m3_series_3(float R[3][3], const float M1[3][3], const float M2[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_4(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_5(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3],
|
||||
const float M4[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_6(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3],
|
||||
const float M4[3][3],
|
||||
const float M5[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_7(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3],
|
||||
const float M4[3][3],
|
||||
const float M5[3][3],
|
||||
const float M6[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_8(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3],
|
||||
const float M4[3][3],
|
||||
const float M5[3][3],
|
||||
const float M6[3][3],
|
||||
const float M7[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_9(float R[3][3],
|
||||
const float M1[3][3],
|
||||
const float M2[3][3],
|
||||
const float M3[3][3],
|
||||
const float M4[3][3],
|
||||
const float M5[3][3],
|
||||
const float M6[3][3],
|
||||
const float M7[3][3],
|
||||
const float M8[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_3(float r[3][3], const float m1[3][3], const float m2[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_4(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_5(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3],
|
||||
const float m4[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_6(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3],
|
||||
const float m4[3][3],
|
||||
const float m5[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_7(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3],
|
||||
const float m4[3][3],
|
||||
const float m5[3][3],
|
||||
const float m6[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_8(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3],
|
||||
const float m4[3][3],
|
||||
const float m5[3][3],
|
||||
const float m6[3][3],
|
||||
const float m7[3][3]) ATTR_NONNULL();
|
||||
void _va_mul_m3_series_9(float r[3][3],
|
||||
const float m1[3][3],
|
||||
const float m2[3][3],
|
||||
const float m3[3][3],
|
||||
const float m4[3][3],
|
||||
const float m5[3][3],
|
||||
const float m6[3][3],
|
||||
const float m7[3][3],
|
||||
const float m8[3][3]) ATTR_NONNULL();
|
||||
|
||||
/* Implement #mul_m4_series macro. */
|
||||
|
||||
void _va_mul_m4_series_3(float R[4][4], const float M1[4][4], const float M2[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_4(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_5(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4],
|
||||
const float M4[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_6(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4],
|
||||
const float M4[4][4],
|
||||
const float M5[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_7(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4],
|
||||
const float M4[4][4],
|
||||
const float M5[4][4],
|
||||
const float M6[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_8(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4],
|
||||
const float M4[4][4],
|
||||
const float M5[4][4],
|
||||
const float M6[4][4],
|
||||
const float M7[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_9(float R[4][4],
|
||||
const float M1[4][4],
|
||||
const float M2[4][4],
|
||||
const float M3[4][4],
|
||||
const float M4[4][4],
|
||||
const float M5[4][4],
|
||||
const float M6[4][4],
|
||||
const float M7[4][4],
|
||||
const float M8[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_3(float r[4][4], const float m1[4][4], const float m2[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_4(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_5(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4],
|
||||
const float m4[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_6(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4],
|
||||
const float m4[4][4],
|
||||
const float m5[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_7(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4],
|
||||
const float m4[4][4],
|
||||
const float m5[4][4],
|
||||
const float m6[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_8(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4],
|
||||
const float m4[4][4],
|
||||
const float m5[4][4],
|
||||
const float m6[4][4],
|
||||
const float m7[4][4]) ATTR_NONNULL();
|
||||
void _va_mul_m4_series_9(float r[4][4],
|
||||
const float m1[4][4],
|
||||
const float m2[4][4],
|
||||
const float m3[4][4],
|
||||
const float m4[4][4],
|
||||
const float m5[4][4],
|
||||
const float m6[4][4],
|
||||
const float m7[4][4],
|
||||
const float m8[4][4]) ATTR_NONNULL();
|
||||
|
||||
#define mul_m3_series(...) VA_NARGS_CALL_OVERLOAD(_va_mul_m3_series_, __VA_ARGS__)
|
||||
#define mul_m4_series(...) VA_NARGS_CALL_OVERLOAD(_va_mul_m4_series_, __VA_ARGS__)
|
||||
|
||||
void mul_m4_v3(const float M[4][4], float r[3]);
|
||||
void mul_v3_m4v3(float r[3], const float M[4][4], const float v[3]);
|
||||
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3]);
|
||||
void mul_v3_m4v3_db(double r[3], const double mat[4][4], const double vec[3]);
|
||||
void mul_v4_m4v3_db(double r[4], const double mat[4][4], const double vec[3]);
|
||||
void mul_v2_m4v3(float r[2], const float M[4][4], const float v[3]);
|
||||
void mul_v2_m2v2(float r[2], const float M[2][2], const float v[2]);
|
||||
void mul_m2_v2(const float M[2][2], float v[2]);
|
||||
void mul_v2_m4v3(float r[2], const float mat[4][4], const float vec[3]);
|
||||
void mul_v2_m2v2(float r[2], const float mat[2][2], const float vec[2]);
|
||||
void mul_m2_v2(const float mat[2][2], float vec[2]);
|
||||
/** Same as #mul_m4_v3() but doesn't apply translation component. */
|
||||
void mul_mat3_m4_v3(const float M[4][4], float r[3]);
|
||||
void mul_v3_mat3_m4v3(float r[3], const float M[4][4], const float v[3]);
|
||||
void mul_v3_mat3_m4v3_db(double r[3], const double M[4][4], const double v[3]);
|
||||
void mul_m4_v4(const float M[4][4], float r[4]);
|
||||
void mul_v4_m4v4(float r[4], const float M[4][4], const float v[4]);
|
||||
void mul_mat3_m4_v3(const float mat[4][4], float r[3]);
|
||||
void mul_v3_mat3_m4v3(float r[3], const float mat[4][4], const float vec[3]);
|
||||
void mul_v3_mat3_m4v3_db(double r[3], const double mat[4][4], const double vec[3]);
|
||||
void mul_m4_v4(const float mat[4][4], float r[4]);
|
||||
void mul_v4_m4v4(float r[4], const float mat[4][4], const float v[4]);
|
||||
void mul_v4_m4v3(float r[4], const float M[4][4], const float v[3]); /* v has implicit w = 1.0f */
|
||||
void mul_project_m4_v3(const float M[4][4], float vec[3]);
|
||||
void mul_project_m4_v3(const float mat[4][4], float vec[3]);
|
||||
void mul_v3_project_m4_v3(float r[3], const float mat[4][4], const float vec[3]);
|
||||
void mul_v2_project_m4_v3(float r[2], const float M[4][4], const float vec[3]);
|
||||
void mul_v2_project_m4_v3(float r[2], const float mat[4][4], const float vec[3]);
|
||||
|
||||
void mul_m3_v2(const float m[3][3], float r[2]);
|
||||
void mul_v2_m3v2(float r[2], const float m[3][3], const float v[2]);
|
||||
|
|
@ -234,14 +234,14 @@ void negate_m3(float R[3][3]);
|
|||
void negate_mat3_m4(float R[4][4]);
|
||||
void negate_m4(float R[4][4]);
|
||||
|
||||
bool invert_m3_ex(float m[3][3], float epsilon);
|
||||
bool invert_m3_m3_ex(float m1[3][3], const float m2[3][3], float epsilon);
|
||||
bool invert_m3_ex(float mat[3][3], float epsilon);
|
||||
bool invert_m3_m3_ex(float inverse[3][3], const float mat[3][3], float epsilon);
|
||||
|
||||
bool invert_m3(float R[3][3]);
|
||||
bool invert_m2_m2(float R[2][2], const float A[2][2]);
|
||||
bool invert_m3_m3(float R[3][3], const float A[3][3]);
|
||||
bool invert_m4(float R[4][4]);
|
||||
bool invert_m4_m4(float R[4][4], const float A[4][4]);
|
||||
bool invert_m3(float mat[3][3]);
|
||||
bool invert_m2_m2(float inverse[2][2], const float mat[2][2]);
|
||||
bool invert_m3_m3(float inverse[3][3], const float mat[3][3]);
|
||||
bool invert_m4(float mat[4][4]);
|
||||
bool invert_m4_m4(float inverse[4][4], const float mat[4][4]);
|
||||
/**
|
||||
* Computes the inverse of mat and puts it in inverse.
|
||||
* Uses Gaussian Elimination with partial (maximal column) pivoting.
|
||||
|
|
@ -252,12 +252,12 @@ bool invert_m4_m4(float R[4][4], const float A[4][4]);
|
|||
* for non-invertible scale matrices, finding a partial solution can
|
||||
* be useful to have a valid local transform center, see T57767.
|
||||
*/
|
||||
bool invert_m4_m4_fallback(float R[4][4], const float A[4][4]);
|
||||
bool invert_m4_m4_fallback(float inverse[4][4], const float mat[4][4]);
|
||||
|
||||
/* Double arithmetic (mixed float/double). */
|
||||
|
||||
void mul_m4_v4d(const float M[4][4], double r[4]);
|
||||
void mul_v4d_m4v4d(double r[4], const float M[4][4], const double v[4]);
|
||||
void mul_m4_v4d(const float mat[4][4], double r[4]);
|
||||
void mul_v4d_m4v4d(double r[4], const float mat[4][4], const double v[4]);
|
||||
|
||||
/* Double matrix functions (no mixing types). */
|
||||
|
||||
|
|
@ -291,8 +291,8 @@ void normalize_m3_m3_ex(float R[3][3], const float M[3][3], float r_scale[3]) AT
|
|||
void normalize_m3_m3(float R[3][3], const float M[3][3]) ATTR_NONNULL();
|
||||
void normalize_m4_ex(float R[4][4], float r_scale[3]) ATTR_NONNULL();
|
||||
void normalize_m4(float R[4][4]) ATTR_NONNULL();
|
||||
void normalize_m4_m4_ex(float R[4][4], const float M[4][4], float r_scale[3]) ATTR_NONNULL();
|
||||
void normalize_m4_m4(float R[4][4], const float M[4][4]) ATTR_NONNULL();
|
||||
void normalize_m4_m4_ex(float rmat[4][4], const float mat[4][4], float r_scale[3]) ATTR_NONNULL();
|
||||
void normalize_m4_m4(float rmat[4][4], const float mat[4][4]) ATTR_NONNULL();
|
||||
|
||||
/**
|
||||
* Make an orthonormal matrix around the selected axis of the given matrix.
|
||||
|
|
@ -326,15 +326,15 @@ void orthogonalize_m3_stable(float R[3][3], int axis, bool normalize);
|
|||
*/
|
||||
void orthogonalize_m4_stable(float R[4][4], int axis, bool normalize);
|
||||
|
||||
bool orthogonalize_m3_zero_axes(float R[3][3], float unit_length);
|
||||
bool orthogonalize_m4_zero_axes(float R[4][4], float unit_length);
|
||||
bool orthogonalize_m3_zero_axes(float m[3][3], float unit_length);
|
||||
bool orthogonalize_m4_zero_axes(float m[4][4], float unit_length);
|
||||
|
||||
bool is_orthogonal_m3(const float mat[3][3]);
|
||||
bool is_orthogonal_m4(const float mat[4][4]);
|
||||
bool is_orthonormal_m3(const float mat[3][3]);
|
||||
bool is_orthonormal_m4(const float mat[4][4]);
|
||||
bool is_orthogonal_m3(const float m[3][3]);
|
||||
bool is_orthogonal_m4(const float m[4][4]);
|
||||
bool is_orthonormal_m3(const float m[3][3]);
|
||||
bool is_orthonormal_m4(const float m[4][4]);
|
||||
|
||||
bool is_uniform_scaled_m3(const float mat[3][3]);
|
||||
bool is_uniform_scaled_m3(const float m[3][3]);
|
||||
bool is_uniform_scaled_m4(const float m[4][4]);
|
||||
|
||||
/* NOTE: 'adjoint' here means the adjugate (adjunct, "classical adjoint") matrix!
|
||||
|
|
@ -362,22 +362,22 @@ float determinant_m4(const float m[4][4]);
|
|||
* From this decomposition it is trivial to compute the (pseudo-inverse)
|
||||
* of `A` as `Ainv = V.Winv.transpose(U)`.
|
||||
*/
|
||||
void svd_m4(float U[4][4], float s[4], float V[4][4], float A[4][4]);
|
||||
void pseudoinverse_m4_m4(float Ainv[4][4], const float A[4][4], float epsilon);
|
||||
void pseudoinverse_m3_m3(float Ainv[3][3], const float A[3][3], float epsilon);
|
||||
void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4]);
|
||||
void pseudoinverse_m4_m4(float inverse[4][4], const float mat[4][4], float epsilon);
|
||||
void pseudoinverse_m3_m3(float inverse[3][3], const float mat[3][3], float epsilon);
|
||||
|
||||
bool has_zero_axis_m4(const float matrix[4][4]);
|
||||
|
||||
void invert_m4_m4_safe(float Ainv[4][4], const float A[4][4]);
|
||||
void invert_m4_m4_safe(float inverse[4][4], const float mat[4][4]);
|
||||
|
||||
void invert_m3_m3_safe_ortho(float Ainv[3][3], const float A[3][3]);
|
||||
void invert_m3_m3_safe_ortho(float inverse[3][3], const float mat[3][3]);
|
||||
/**
|
||||
* A safe version of invert that uses valid axes, calculating the zero'd axis
|
||||
* based on the non-zero ones.
|
||||
*
|
||||
* This works well for transformation matrices, when a single axis is zeroed.
|
||||
*/
|
||||
void invert_m4_m4_safe_ortho(float Ainv[4][4], const float A[4][4]);
|
||||
void invert_m4_m4_safe_ortho(float inverse[4][4], const float mat[4][4]);
|
||||
|
||||
/** \} */
|
||||
|
||||
|
|
@ -394,18 +394,18 @@ void scale_m4_v2(float R[4][4], const float scale[2]);
|
|||
* For an orthogonal matrix, it is the product of all three scale values.
|
||||
* Returns a negative value if the transform is flipped by negative scale.
|
||||
*/
|
||||
float mat3_to_volume_scale(const float M[3][3]);
|
||||
float mat4_to_volume_scale(const float M[4][4]);
|
||||
float mat3_to_volume_scale(const float mat[3][3]);
|
||||
float mat4_to_volume_scale(const float mat[4][4]);
|
||||
|
||||
/**
|
||||
* This gets the average scale of a matrix, only use when your scaling
|
||||
* data that has no idea of scale axis, examples are bone-envelope-radius
|
||||
* and curve radius.
|
||||
*/
|
||||
float mat3_to_scale(const float M[3][3]);
|
||||
float mat4_to_scale(const float M[4][4]);
|
||||
float mat3_to_scale(const float mat[3][3]);
|
||||
float mat4_to_scale(const float mat[4][4]);
|
||||
/** Return 2D scale (in XY plane) of given mat4. */
|
||||
float mat4_to_xy_scale(const float M[4][4]);
|
||||
float mat4_to_xy_scale(const float mat[4][4]);
|
||||
|
||||
void size_to_mat3(float R[3][3], const float size[3]);
|
||||
void size_to_mat4(float R[4][4], const float size[3]);
|
||||
|
|
@ -433,7 +433,7 @@ float mat4_to_size_max_axis(const float M[4][4]);
|
|||
*/
|
||||
void mat4_to_size_fix_shear(float size[3], const float M[4][4]);
|
||||
|
||||
void translate_m4(float mat[4][4], float tx, float ty, float tz);
|
||||
void translate_m4(float mat[4][4], float Tx, float Ty, float Tz);
|
||||
/**
|
||||
* Rotate a matrix in-place.
|
||||
*
|
||||
|
|
@ -605,8 +605,8 @@ void BLI_space_transform_invert_normal(const struct SpaceTransform *data, float
|
|||
/** \name Other
|
||||
* \{ */
|
||||
|
||||
void print_m3(const char *str, const float M[3][3]);
|
||||
void print_m4(const char *str, const float M[4][4]);
|
||||
void print_m3(const char *str, const float m[3][3]);
|
||||
void print_m4(const char *str, const float m[4][4]);
|
||||
|
||||
#define print_m3_id(M) print_m3(STRINGIFY(M), M)
|
||||
#define print_m4_id(M) print_m4(STRINGIFY(M), M)
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ void mul_qt_fl(float q[4], float f);
|
|||
/**
|
||||
* Raise a unit quaternion to the specified power.
|
||||
*/
|
||||
void pow_qt_fl_normalized(float q[4], float f);
|
||||
void pow_qt_fl_normalized(float q[4], float fac);
|
||||
|
||||
void sub_qt_qtqt(float q[4], const float a[4], const float b[4]);
|
||||
|
||||
|
|
@ -109,8 +109,8 @@ void add_qt_qtqt(float q[4], const float a[4], const float b[4], float t);
|
|||
|
||||
/* Conversion. */
|
||||
|
||||
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 quat_to_mat3(float m[3][3], const float q[4]);
|
||||
void quat_to_mat4(float m[4][4], const float q[4]);
|
||||
|
||||
/**
|
||||
* Apply the rotation of \a a to \a q keeping the values compatible with \a old.
|
||||
|
|
@ -157,7 +157,10 @@ void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q
|
|||
* \param r_twist: if not NULL, receives the twist quaternion.
|
||||
* \returns twist angle.
|
||||
*/
|
||||
float quat_split_swing_and_twist(const float q[4], int axis, float r_swing[4], float r_twist[4]);
|
||||
float quat_split_swing_and_twist(const float q_in[4],
|
||||
int axis,
|
||||
float r_swing[4],
|
||||
float r_twist[4]);
|
||||
|
||||
float angle_normalized_qt(const float q[4]);
|
||||
float angle_normalized_qtqt(const float q1[4], const float q2[4]);
|
||||
|
|
@ -172,7 +175,7 @@ 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], const float mat[3][3]);
|
||||
void mat3_to_quat_is_ok(float q[4], const float wmat[3][3]);
|
||||
|
||||
/* Other. */
|
||||
|
||||
|
|
@ -235,16 +238,16 @@ void axis_angle_to_mat4(float R[4][4], const float axis[3], float angle);
|
|||
/**
|
||||
* 3x3 matrix to axis angle.
|
||||
*/
|
||||
void mat3_normalized_to_axis_angle(float axis[3], float *angle, const float M[3][3]);
|
||||
void mat3_normalized_to_axis_angle(float axis[3], float *angle, const float mat[3][3]);
|
||||
/**
|
||||
* 4x4 matrix to axis angle.
|
||||
*/
|
||||
void mat4_normalized_to_axis_angle(float axis[3], float *angle, const float M[4][4]);
|
||||
void mat3_to_axis_angle(float axis[3], float *angle, const float M[3][3]);
|
||||
void mat4_normalized_to_axis_angle(float axis[3], float *angle, const float mat[4][4]);
|
||||
void mat3_to_axis_angle(float axis[3], float *angle, const float mat[3][3]);
|
||||
/**
|
||||
* 4x4 matrix to axis angle.
|
||||
*/
|
||||
void mat4_to_axis_angle(float axis[3], float *angle, const float M[4][4]);
|
||||
void mat4_to_axis_angle(float axis[3], float *angle, const float mat[4][4]);
|
||||
/**
|
||||
* Quaternions to Axis Angle.
|
||||
*/
|
||||
|
|
@ -283,19 +286,19 @@ 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 mat3_normalized_to_eul(float eul[3], const float mat[3][3]);
|
||||
void mat4_normalized_to_eul(float eul[3], const float mat[4][4]);
|
||||
void mat4_normalized_to_eul(float eul[3], const float m[4][4]);
|
||||
void mat3_to_eul(float eul[3], const float mat[3][3]);
|
||||
void mat4_to_eul(float eul[3], const float mat[4][4]);
|
||||
void quat_to_eul(float eul[3], const float quat[4]);
|
||||
|
||||
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 mat3_normalized_to_compatible_eul(float eul[3], const float oldrot[3], float mat[3][3]);
|
||||
void mat3_to_compatible_eul(float eul[3], const float oldrot[3], float mat[3][3]);
|
||||
void quat_to_compatible_eul(float eul[3], const float oldrot[3], const float quat[4]);
|
||||
void rotate_eul(float eul[3], char axis, float angle);
|
||||
void rotate_eul(float beul[3], char axis, float angle);
|
||||
|
||||
/* Order independent. */
|
||||
|
||||
void compatible_eul(float eul[3], const float old[3]);
|
||||
void compatible_eul(float eul[3], const float oldrot[3]);
|
||||
|
||||
void add_eul_euleul(float r_eul[3], float a[3], float b[3], short order);
|
||||
void sub_eul_euleul(float r_eul[3], float a[3], float b[3], short order);
|
||||
|
|
@ -323,15 +326,15 @@ typedef enum eEulerRotationOrders {
|
|||
/**
|
||||
* Construct quaternion from Euler angles (in radians).
|
||||
*/
|
||||
void eulO_to_quat(float quat[4], const float eul[3], short order);
|
||||
void eulO_to_quat(float q[4], const float e[3], short order);
|
||||
/**
|
||||
* Construct 3x3 matrix from Euler angles (in radians).
|
||||
*/
|
||||
void eulO_to_mat3(float mat[3][3], const float eul[3], short order);
|
||||
void eulO_to_mat3(float M[3][3], const float e[3], short order);
|
||||
/**
|
||||
* Construct 4x4 matrix from Euler angles (in radians).
|
||||
*/
|
||||
void eulO_to_mat4(float mat[4][4], const float eul[3], short order);
|
||||
void eulO_to_mat4(float mat[4][4], const float e[3], short order);
|
||||
/**
|
||||
* Euler Rotation to Axis Angle.
|
||||
*/
|
||||
|
|
@ -344,17 +347,17 @@ void eulO_to_gimbal_axis(float gmat[3][3], const float eul[3], short order);
|
|||
/**
|
||||
* Convert 3x3 matrix to Euler angles (in radians).
|
||||
*/
|
||||
void mat3_normalized_to_eulO(float eul[3], short order, const float mat[3][3]);
|
||||
void mat3_normalized_to_eulO(float eul[3], short order, const float m[3][3]);
|
||||
/**
|
||||
* Convert 4x4 matrix to Euler angles (in radians).
|
||||
*/
|
||||
void mat4_normalized_to_eulO(float eul[3], short order, const float mat[4][4]);
|
||||
void mat3_to_eulO(float eul[3], short order, const float mat[3][3]);
|
||||
void mat4_to_eulO(float eul[3], short order, const float mat[4][4]);
|
||||
void mat4_normalized_to_eulO(float eul[3], short order, const float m[4][4]);
|
||||
void mat3_to_eulO(float eul[3], short order, const float m[3][3]);
|
||||
void mat4_to_eulO(float eul[3], short order, const float m[4][4]);
|
||||
/**
|
||||
* Convert quaternion to Euler angles (in radians).
|
||||
*/
|
||||
void quat_to_eulO(float eul[3], short order, const float quat[4]);
|
||||
void quat_to_eulO(float e[3], short order, const float q[4]);
|
||||
/**
|
||||
* Axis Angle to Euler Rotation.
|
||||
*/
|
||||
|
|
@ -363,18 +366,27 @@ void axis_angle_to_eulO(float eul[3], short order, const float axis[3], float an
|
|||
/* Uses 2 methods to retrieve eulers, and picks the closest. */
|
||||
|
||||
void mat3_normalized_to_compatible_eulO(float eul[3],
|
||||
const float old[3],
|
||||
const float oldrot[3],
|
||||
short order,
|
||||
const float mat[3][3]);
|
||||
void mat4_normalized_to_compatible_eulO(float eul[3],
|
||||
const float old[3],
|
||||
const float oldrot[3],
|
||||
short order,
|
||||
const float mat[4][4]);
|
||||
void mat3_to_compatible_eulO(float eul[3], const float old[3], short order, const float mat[3][3]);
|
||||
void mat4_to_compatible_eulO(float eul[3], const float old[3], short order, const float mat[4][4]);
|
||||
void quat_to_compatible_eulO(float eul[3], const float old[3], short order, const float quat[4]);
|
||||
void mat3_to_compatible_eulO(float eul[3],
|
||||
const float oldrot[3],
|
||||
short order,
|
||||
const float mat[3][3]);
|
||||
void mat4_to_compatible_eulO(float eul[3],
|
||||
const float oldrot[3],
|
||||
short order,
|
||||
const float mat[4][4]);
|
||||
void quat_to_compatible_eulO(float eul[3],
|
||||
const float oldrot[3],
|
||||
short order,
|
||||
const float quat[4]);
|
||||
|
||||
void rotate_eulO(float eul[3], short order, char axis, float angle);
|
||||
void rotate_eulO(float beul[3], short order, char axis, float angle);
|
||||
|
||||
/** \} */
|
||||
|
||||
|
|
@ -383,7 +395,7 @@ void rotate_eulO(float eul[3], short order, char axis, float angle);
|
|||
* \{ */
|
||||
|
||||
void copy_dq_dq(DualQuat *r, const DualQuat *dq);
|
||||
void normalize_dq(DualQuat *dq, float totw);
|
||||
void normalize_dq(DualQuat *dq, float totweight);
|
||||
void add_weighted_dq_dq(DualQuat *dq_sum, const DualQuat *dq, float weight);
|
||||
void mul_v3m3_dq(float r[3], float R[3][3], DualQuat *dq);
|
||||
|
||||
|
|
@ -400,7 +412,7 @@ void vec_apply_track(float vec[3], short axis);
|
|||
* Lens/angle conversion (radians).
|
||||
*/
|
||||
float focallength_to_fov(float focal_length, float sensor);
|
||||
float fov_to_focallength(float fov, float sensor);
|
||||
float fov_to_focallength(float hfov, float sensor);
|
||||
|
||||
float angle_wrap_rad(float angle);
|
||||
float angle_wrap_deg(float angle);
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ MINLINE void mul_v3_v3db_db(double r[3], const double a[3], double f);
|
|||
MINLINE void mul_v2_v2(float r[2], const float a[2]);
|
||||
MINLINE void mul_v2_v2v2(float r[2], const float a[2], const float b[2]);
|
||||
MINLINE void mul_v3_v3(float r[3], const float a[3]);
|
||||
MINLINE void mul_v3_v3v3(float r[3], const float a[3], const float b[3]);
|
||||
MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3]);
|
||||
MINLINE void mul_v4_fl(float r[4], float f);
|
||||
MINLINE void mul_v4_v4(float r[4], const float a[4]);
|
||||
MINLINE void mul_v4_v4fl(float r[4], const float a[4], float f);
|
||||
|
|
@ -271,10 +271,10 @@ MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
|
|||
MINLINE float len_manhattan_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE int len_manhattan_v2_int(const int v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_manhattan_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_v2(const float a[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE double len_v2_db(const double v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE double len_v2v2_db(const double a[2], const double b[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE double len_v2v2_db(const double v1[2], const double v2[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float len_v2v2_int(const int v1[2], const int v2[2]);
|
||||
MINLINE float len_squared_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE double len_squared_v2v2_db(const double a[2], const double b[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
|
@ -288,22 +288,22 @@ MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESU
|
|||
|
||||
MINLINE double len_v3_db(const double a[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE double len_squared_v3_db(const double v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE float normalize_v2_length(float r[2], float unit_scale);
|
||||
MINLINE float normalize_v2_length(float n[2], float unit_length);
|
||||
/**
|
||||
* \note any vectors containing `nan` will be zeroed out.
|
||||
*/
|
||||
MINLINE float normalize_v2_v2_length(float r[2], const float a[2], float unit_scale);
|
||||
MINLINE float normalize_v3_length(float r[3], float unit_scale);
|
||||
MINLINE float normalize_v2_v2_length(float r[2], const float a[2], float unit_length);
|
||||
MINLINE float normalize_v3_length(float n[3], float unit_length);
|
||||
/**
|
||||
* \note any vectors containing `nan` will be zeroed out.
|
||||
*/
|
||||
MINLINE float normalize_v3_v3_length(float r[3], const float a[3], float unit_scale);
|
||||
MINLINE double normalize_v3_length_db(double n[3], double unit_scale);
|
||||
MINLINE double normalize_v3_v3_length_db(double r[3], const double a[3], double unit_scale);
|
||||
MINLINE float normalize_v3_v3_length(float r[3], const float a[3], float unit_length);
|
||||
MINLINE double normalize_v3_length_db(double n[3], double unit_length);
|
||||
MINLINE double normalize_v3_v3_length_db(double r[3], const double a[3], double unit_length);
|
||||
|
||||
MINLINE float normalize_v2(float r[2]);
|
||||
MINLINE float normalize_v2(float n[2]);
|
||||
MINLINE float normalize_v2_v2(float r[2], const float a[2]);
|
||||
MINLINE float normalize_v3(float r[3]);
|
||||
MINLINE float normalize_v3(float n[3]);
|
||||
MINLINE float normalize_v3_v3(float r[3], const float a[3]);
|
||||
MINLINE double normalize_v3_v3_db(double r[3], const double a[3]);
|
||||
MINLINE double normalize_v3_db(double n[3]);
|
||||
|
|
@ -424,45 +424,51 @@ void flip_v2_v2v2(float v[2], const float v1[2], const float v2[2]);
|
|||
/** \name Comparison
|
||||
* \{ */
|
||||
|
||||
MINLINE bool is_zero_v2(const float a[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v4(const float a[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v4(const float v[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool is_zero_v2_db(const double a[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v3_db(const double a[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v4_db(const double a[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v2_db(const double v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v3_db(const double v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_zero_v4_db(const double v[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
bool is_finite_v2(const float a[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
bool is_finite_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
bool is_finite_v4(const float a[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
bool is_finite_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
bool is_finite_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
bool is_finite_v4(const float v[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool is_one_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool is_one_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v4v4(const float a[4], const float b[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v4v4(const float v1[4], const float v2[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool equals_v2v2_int(const int v1[2], const int v2[2]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v3v3_int(const int v1[3], const int v2[3]) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool equals_v4v4_int(const int v1[4], const int v2[4]) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool compare_v2v2(const float a[2], const float b[2], float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v3v3(const float a[3], const float b[3], float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v4v4(const float a[4], const float b[4], float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v2v2(const float v1[2],
|
||||
const float v2[2],
|
||||
float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v3v3(const float v1[3],
|
||||
const float v2[3],
|
||||
float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v4v4(const float v1[4],
|
||||
const float v2[4],
|
||||
float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool compare_v2v2_relative(const float a[2], const float b[2], float limit, int max_ulps)
|
||||
MINLINE bool compare_v2v2_relative(const float v1[2], const float v2[2], float limit, int max_ulps)
|
||||
ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v3v3_relative(const float a[3], const float b[3], float limit, int max_ulps)
|
||||
MINLINE bool compare_v3v3_relative(const float v1[3], const float v2[3], float limit, int max_ulps)
|
||||
ATTR_WARN_UNUSED_RESULT;
|
||||
MINLINE bool compare_v4v4_relative(const float a[4], const float b[4], float limit, int max_ulps)
|
||||
MINLINE bool compare_v4v4_relative(const float v1[4], const float v2[4], float limit, int max_ulps)
|
||||
ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool compare_len_v3v3(const float a[3],
|
||||
const float b[3],
|
||||
MINLINE bool compare_len_v3v3(const float v1[3],
|
||||
const float v2[3],
|
||||
float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
MINLINE bool compare_size_v3v3(const float a[3],
|
||||
const float b[3],
|
||||
MINLINE bool compare_size_v3v3(const float v1[3],
|
||||
const float v2[3],
|
||||
float limit) ATTR_WARN_UNUSED_RESULT;
|
||||
|
||||
/**
|
||||
|
|
@ -606,8 +612,8 @@ void project_v3_plane(float out[3], const float plane_no[3], const float plane_c
|
|||
* out: result (negate for a 'bounce').
|
||||
* </pre>
|
||||
*/
|
||||
void reflect_v3_v3v3(float out[3], const float vec[3], const float normal[3]);
|
||||
void reflect_v3_v3v3_db(double out[3], const double vec[3], const double normal[3]);
|
||||
void reflect_v3_v3v3(float out[3], const float v[3], const float normal[3]);
|
||||
void reflect_v3_v3v3_db(double out[3], const double v[3], const double normal[3]);
|
||||
/**
|
||||
* Takes a vector and computes 2 orthogonal directions.
|
||||
*
|
||||
|
|
@ -655,10 +661,10 @@ void print_vn(const char *str, const float v[], int n);
|
|||
#define print_v4_id(v) print_v4(STRINGIFY(v), v)
|
||||
#define print_vn_id(v, n) print_vn(STRINGIFY(v), v, n)
|
||||
|
||||
MINLINE void normal_float_to_short_v2(short r[2], const float n[2]);
|
||||
MINLINE void normal_short_to_float_v3(float r[3], const short n[3]);
|
||||
MINLINE void normal_float_to_short_v3(short r[3], const float n[3]);
|
||||
MINLINE void normal_float_to_short_v4(short r[4], const float n[4]);
|
||||
MINLINE void normal_float_to_short_v2(short out[2], const float in[2]);
|
||||
MINLINE void normal_short_to_float_v3(float out[3], const short in[3]);
|
||||
MINLINE void normal_float_to_short_v3(short out[3], const float in[3]);
|
||||
MINLINE void normal_float_to_short_v4(short out[4], const float in[4]);
|
||||
|
||||
void minmax_v4v4_v4(float min[4], float max[4], const float vec[4]);
|
||||
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3]);
|
||||
|
|
|
|||
|
|
@ -157,8 +157,8 @@ size_t BLI_strnlen_utf8(const char *strc, size_t maxlen) ATTR_NONNULL(1) ATTR_WA
|
|||
size_t BLI_strncpy_wchar_as_utf8(char *__restrict dst,
|
||||
const wchar_t *__restrict src,
|
||||
size_t maxncpy) ATTR_NONNULL(1, 2);
|
||||
size_t BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst,
|
||||
const char *__restrict src,
|
||||
size_t BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst_w,
|
||||
const char *__restrict src_c,
|
||||
size_t maxncpy) ATTR_NONNULL(1, 2);
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -787,14 +787,14 @@ void mul_m2_v2(const float mat[2][2], float vec[2])
|
|||
mul_v2_m2v2(vec, mat, vec);
|
||||
}
|
||||
|
||||
void mul_mat3_m4_v3(const float M[4][4], float r[3])
|
||||
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
|
||||
{
|
||||
const float x = r[0];
|
||||
const float y = r[1];
|
||||
|
||||
r[0] = x * M[0][0] + y * M[1][0] + M[2][0] * r[2];
|
||||
r[1] = x * M[0][1] + y * M[1][1] + M[2][1] * r[2];
|
||||
r[2] = x * M[0][2] + y * M[1][2] + M[2][2] * r[2];
|
||||
r[0] = x * mat[0][0] + y * mat[1][0] + mat[2][0] * r[2];
|
||||
r[1] = x * mat[0][1] + y * mat[1][1] + mat[2][1] * r[2];
|
||||
r[2] = x * mat[0][2] + y * mat[1][2] + mat[2][2] * r[2];
|
||||
}
|
||||
|
||||
void mul_v3_mat3_m4v3(float r[3], const float mat[4][4], const float vec[3])
|
||||
|
|
@ -1116,32 +1116,32 @@ double determinant_m3_array_db(const double m[3][3])
|
|||
m[2][0] * (m[0][1] * m[1][2] - m[0][2] * m[1][1]));
|
||||
}
|
||||
|
||||
bool invert_m2_m2(float m1[2][2], const float m2[2][2])
|
||||
bool invert_m2_m2(float inverse[2][2], const float mat[2][2])
|
||||
{
|
||||
adjoint_m2_m2(m1, m2);
|
||||
float det = determinant_m2(m2[0][0], m2[1][0], m2[0][1], m2[1][1]);
|
||||
adjoint_m2_m2(inverse, mat);
|
||||
float det = determinant_m2(mat[0][0], mat[1][0], mat[0][1], mat[1][1]);
|
||||
|
||||
bool success = (det != 0.0f);
|
||||
if (success) {
|
||||
m1[0][0] /= det;
|
||||
m1[1][0] /= det;
|
||||
m1[0][1] /= det;
|
||||
m1[1][1] /= det;
|
||||
inverse[0][0] /= det;
|
||||
inverse[1][0] /= det;
|
||||
inverse[0][1] /= det;
|
||||
inverse[1][1] /= det;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
bool invert_m3_ex(float m[3][3], const float epsilon)
|
||||
bool invert_m3_ex(float mat[3][3], const float epsilon)
|
||||
{
|
||||
float tmp[3][3];
|
||||
const bool success = invert_m3_m3_ex(tmp, m, epsilon);
|
||||
float mat_tmp[3][3];
|
||||
const bool success = invert_m3_m3_ex(mat_tmp, mat, epsilon);
|
||||
|
||||
copy_m3_m3(m, tmp);
|
||||
copy_m3_m3(mat, mat_tmp);
|
||||
return success;
|
||||
}
|
||||
|
||||
bool invert_m3_m3_ex(float m1[3][3], const float m2[3][3], const float epsilon)
|
||||
bool invert_m3_m3_ex(float inverse[3][3], const float mat[3][3], const float epsilon)
|
||||
{
|
||||
float det;
|
||||
int a, b;
|
||||
|
|
@ -1150,10 +1150,10 @@ bool invert_m3_m3_ex(float m1[3][3], const float m2[3][3], const float epsilon)
|
|||
BLI_assert(epsilon >= 0.0f);
|
||||
|
||||
/* calc adjoint */
|
||||
adjoint_m3_m3(m1, m2);
|
||||
adjoint_m3_m3(inverse, mat);
|
||||
|
||||
/* then determinant old matrix! */
|
||||
det = determinant_m3_array(m2);
|
||||
det = determinant_m3_array(mat);
|
||||
|
||||
success = (fabsf(det) > epsilon);
|
||||
|
||||
|
|
@ -1161,33 +1161,33 @@ bool invert_m3_m3_ex(float m1[3][3], const float m2[3][3], const float epsilon)
|
|||
det = 1.0f / det;
|
||||
for (a = 0; a < 3; a++) {
|
||||
for (b = 0; b < 3; b++) {
|
||||
m1[a][b] *= det;
|
||||
inverse[a][b] *= det;
|
||||
}
|
||||
}
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
bool invert_m3(float m[3][3])
|
||||
bool invert_m3(float mat[3][3])
|
||||
{
|
||||
float tmp[3][3];
|
||||
const bool success = invert_m3_m3(tmp, m);
|
||||
float mat_tmp[3][3];
|
||||
const bool success = invert_m3_m3(mat_tmp, mat);
|
||||
|
||||
copy_m3_m3(m, tmp);
|
||||
copy_m3_m3(mat, mat_tmp);
|
||||
return success;
|
||||
}
|
||||
|
||||
bool invert_m3_m3(float m1[3][3], const float m2[3][3])
|
||||
bool invert_m3_m3(float inverse[3][3], const float mat[3][3])
|
||||
{
|
||||
float det;
|
||||
int a, b;
|
||||
bool success;
|
||||
|
||||
/* calc adjoint */
|
||||
adjoint_m3_m3(m1, m2);
|
||||
adjoint_m3_m3(inverse, mat);
|
||||
|
||||
/* then determinant old matrix! */
|
||||
det = determinant_m3_array(m2);
|
||||
det = determinant_m3_array(mat);
|
||||
|
||||
success = (det != 0.0f);
|
||||
|
||||
|
|
@ -1195,7 +1195,7 @@ bool invert_m3_m3(float m1[3][3], const float m2[3][3])
|
|||
det = 1.0f / det;
|
||||
for (a = 0; a < 3; a++) {
|
||||
for (b = 0; b < 3; b++) {
|
||||
m1[a][b] *= det;
|
||||
inverse[a][b] *= det;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1203,12 +1203,12 @@ bool invert_m3_m3(float m1[3][3], const float m2[3][3])
|
|||
return success;
|
||||
}
|
||||
|
||||
bool invert_m4(float m[4][4])
|
||||
bool invert_m4(float mat[4][4])
|
||||
{
|
||||
float tmp[4][4];
|
||||
const bool success = invert_m4_m4(tmp, m);
|
||||
float mat_tmp[4][4];
|
||||
const bool success = invert_m4_m4(mat_tmp, mat);
|
||||
|
||||
copy_m4_m4(m, tmp);
|
||||
copy_m4_m4(mat, mat_tmp);
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -2191,11 +2191,11 @@ float mat4_to_scale(const float mat[4][4])
|
|||
return len_v3(unit_vec);
|
||||
}
|
||||
|
||||
float mat4_to_xy_scale(const float M[4][4])
|
||||
float mat4_to_xy_scale(const float mat[4][4])
|
||||
{
|
||||
/* unit length vector in xy plane */
|
||||
float unit_vec[3] = {(float)M_SQRT1_2, (float)M_SQRT1_2, 0.0f};
|
||||
mul_mat3_m4_v3(M, unit_vec);
|
||||
mul_mat3_m4_v3(mat, unit_vec);
|
||||
return len_v3(unit_vec);
|
||||
}
|
||||
|
||||
|
|
@ -2568,11 +2568,8 @@ void loc_eul_size_to_mat4(float R[4][4],
|
|||
R[3][2] = loc[2];
|
||||
}
|
||||
|
||||
void loc_eulO_size_to_mat4(float R[4][4],
|
||||
const float loc[3],
|
||||
const float eul[3],
|
||||
const float size[3],
|
||||
const short rotOrder)
|
||||
void loc_eulO_size_to_mat4(
|
||||
float R[4][4], const float loc[3], const float eul[3], const float size[3], const short order)
|
||||
{
|
||||
float rmat[3][3], smat[3][3], tmat[3][3];
|
||||
|
||||
|
|
@ -2580,7 +2577,7 @@ void loc_eulO_size_to_mat4(float R[4][4],
|
|||
unit_m4(R);
|
||||
|
||||
/* Make rotation + scaling part. */
|
||||
eulO_to_mat3(rmat, eul, rotOrder);
|
||||
eulO_to_mat3(rmat, eul, order);
|
||||
size_to_mat3(smat, size);
|
||||
mul_m3_m3m3(tmat, rmat, smat);
|
||||
|
||||
|
|
@ -3082,14 +3079,14 @@ void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
|
|||
}
|
||||
}
|
||||
|
||||
void pseudoinverse_m4_m4(float Ainv[4][4], const float A_[4][4], float epsilon)
|
||||
void pseudoinverse_m4_m4(float inverse[4][4], const float mat[4][4], float epsilon)
|
||||
{
|
||||
/* compute Moore-Penrose pseudo inverse of matrix, singular values
|
||||
* below epsilon are ignored for stability (truncated SVD) */
|
||||
float A[4][4], V[4][4], W[4], Wm[4][4], U[4][4];
|
||||
int i;
|
||||
|
||||
transpose_m4_m4(A, A_);
|
||||
transpose_m4_m4(A, mat);
|
||||
svd_m4(V, W, U, A);
|
||||
transpose_m4(U);
|
||||
transpose_m4(V);
|
||||
|
|
@ -3101,18 +3098,18 @@ void pseudoinverse_m4_m4(float Ainv[4][4], const float A_[4][4], float epsilon)
|
|||
|
||||
transpose_m4(V);
|
||||
|
||||
mul_m4_series(Ainv, U, Wm, V);
|
||||
mul_m4_series(inverse, U, Wm, V);
|
||||
}
|
||||
|
||||
void pseudoinverse_m3_m3(float Ainv[3][3], const float A[3][3], float epsilon)
|
||||
void pseudoinverse_m3_m3(float inverse[3][3], const float mat[3][3], float epsilon)
|
||||
{
|
||||
/* try regular inverse when possible, otherwise fall back to slow svd */
|
||||
if (!invert_m3_m3(Ainv, A)) {
|
||||
float tmp[4][4], tmpinv[4][4];
|
||||
if (!invert_m3_m3(inverse, mat)) {
|
||||
float mat_tmp[4][4], tmpinv[4][4];
|
||||
|
||||
copy_m4_m3(tmp, A);
|
||||
pseudoinverse_m4_m4(tmpinv, tmp, epsilon);
|
||||
copy_m3_m4(Ainv, tmpinv);
|
||||
copy_m4_m3(mat_tmp, mat);
|
||||
pseudoinverse_m4_m4(tmpinv, mat_tmp, epsilon);
|
||||
copy_m3_m4(inverse, tmpinv);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3122,22 +3119,22 @@ bool has_zero_axis_m4(const float matrix[4][4])
|
|||
len_squared_v3(matrix[2]) < FLT_EPSILON;
|
||||
}
|
||||
|
||||
void invert_m4_m4_safe(float Ainv[4][4], const float A[4][4])
|
||||
void invert_m4_m4_safe(float inverse[4][4], const float mat[4][4])
|
||||
{
|
||||
if (!invert_m4_m4(Ainv, A)) {
|
||||
float Atemp[4][4];
|
||||
if (!invert_m4_m4(inverse, mat)) {
|
||||
float mat_tmp[4][4];
|
||||
|
||||
copy_m4_m4(Atemp, A);
|
||||
copy_m4_m4(mat_tmp, mat);
|
||||
|
||||
/* Matrix is degenerate (e.g. 0 scale on some axis), ideally we should
|
||||
* never be in this situation, but try to invert it anyway with tweak.
|
||||
*/
|
||||
Atemp[0][0] += 1e-8f;
|
||||
Atemp[1][1] += 1e-8f;
|
||||
Atemp[2][2] += 1e-8f;
|
||||
mat_tmp[0][0] += 1e-8f;
|
||||
mat_tmp[1][1] += 1e-8f;
|
||||
mat_tmp[2][2] += 1e-8f;
|
||||
|
||||
if (!invert_m4_m4(Ainv, Atemp)) {
|
||||
unit_m4(Ainv);
|
||||
if (!invert_m4_m4(inverse, mat_tmp)) {
|
||||
unit_m4(inverse);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3157,24 +3154,24 @@ void invert_m4_m4_safe(float Ainv[4][4], const float A[4][4])
|
|||
* where we want to specify the length of the degenerate axes.
|
||||
* \{ */
|
||||
|
||||
void invert_m4_m4_safe_ortho(float Ainv[4][4], const float A[4][4])
|
||||
void invert_m4_m4_safe_ortho(float inverse[4][4], const float mat[4][4])
|
||||
{
|
||||
if (UNLIKELY(!invert_m4_m4(Ainv, A))) {
|
||||
float Atemp[4][4];
|
||||
copy_m4_m4(Atemp, A);
|
||||
if (UNLIKELY(!(orthogonalize_m4_zero_axes(Atemp, 1.0f) && invert_m4_m4(Ainv, Atemp)))) {
|
||||
unit_m4(Ainv);
|
||||
if (UNLIKELY(!invert_m4_m4(inverse, mat))) {
|
||||
float mat_tmp[4][4];
|
||||
copy_m4_m4(mat_tmp, mat);
|
||||
if (UNLIKELY(!(orthogonalize_m4_zero_axes(mat_tmp, 1.0f) && invert_m4_m4(inverse, mat_tmp)))) {
|
||||
unit_m4(inverse);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void invert_m3_m3_safe_ortho(float Ainv[3][3], const float A[3][3])
|
||||
void invert_m3_m3_safe_ortho(float inverse[3][3], const float mat[3][3])
|
||||
{
|
||||
if (UNLIKELY(!invert_m3_m3(Ainv, A))) {
|
||||
float Atemp[3][3];
|
||||
copy_m3_m3(Atemp, A);
|
||||
if (UNLIKELY(!(orthogonalize_m3_zero_axes(Atemp, 1.0f) && invert_m3_m3(Ainv, Atemp)))) {
|
||||
unit_m3(Ainv);
|
||||
if (UNLIKELY(!invert_m3_m3(inverse, mat))) {
|
||||
float mat_tmp[3][3];
|
||||
copy_m3_m3(mat_tmp, mat);
|
||||
if (UNLIKELY(!(orthogonalize_m3_zero_axes(mat_tmp, 1.0f) && invert_m3_m3(inverse, mat_tmp)))) {
|
||||
unit_m3(inverse);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -332,29 +332,29 @@ void mat3_normalized_to_quat(float q[4], const float mat[3][3])
|
|||
|
||||
normalize_qt(q);
|
||||
}
|
||||
void mat3_to_quat(float q[4], const float m[3][3])
|
||||
void mat3_to_quat(float q[4], const float mat[3][3])
|
||||
{
|
||||
float unit_mat[3][3];
|
||||
|
||||
/* work on a copy */
|
||||
/* this is needed AND a 'normalize_qt' in the end */
|
||||
normalize_m3_m3(unit_mat, m);
|
||||
normalize_m3_m3(unit_mat, mat);
|
||||
mat3_normalized_to_quat(q, unit_mat);
|
||||
}
|
||||
|
||||
void mat4_normalized_to_quat(float q[4], const float m[4][4])
|
||||
void mat4_normalized_to_quat(float q[4], const float mat[4][4])
|
||||
{
|
||||
float mat3[3][3];
|
||||
|
||||
copy_m3_m4(mat3, m);
|
||||
copy_m3_m4(mat3, mat);
|
||||
mat3_normalized_to_quat(q, mat3);
|
||||
}
|
||||
|
||||
void mat4_to_quat(float q[4], const float m[4][4])
|
||||
void mat4_to_quat(float q[4], const float mat[4][4])
|
||||
{
|
||||
float mat3[3][3];
|
||||
|
||||
copy_m3_m4(mat3, m);
|
||||
copy_m3_m4(mat3, mat);
|
||||
mat3_to_quat(q, mat3);
|
||||
}
|
||||
|
||||
|
|
@ -498,7 +498,10 @@ void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q
|
|||
mul_qt_qtqt(q, tquat, q2);
|
||||
}
|
||||
|
||||
float quat_split_swing_and_twist(const float q_in[4], int axis, float r_swing[4], float r_twist[4])
|
||||
float quat_split_swing_and_twist(const float q_in[4],
|
||||
const int axis,
|
||||
float r_swing[4],
|
||||
float r_twist[4])
|
||||
{
|
||||
BLI_assert(axis >= 0 && axis <= 2);
|
||||
|
||||
|
|
@ -1381,10 +1384,10 @@ void mat4_normalized_to_eul(float eul[3], const float m[4][4])
|
|||
copy_m3_m4(mat3, m);
|
||||
mat3_normalized_to_eul(eul, mat3);
|
||||
}
|
||||
void mat4_to_eul(float eul[3], const float m[4][4])
|
||||
void mat4_to_eul(float eul[3], const float mat[4][4])
|
||||
{
|
||||
float mat3[3][3];
|
||||
copy_m3_m4(mat3, m);
|
||||
copy_m3_m4(mat3, mat);
|
||||
mat3_to_eul(eul, mat3);
|
||||
}
|
||||
|
||||
|
|
@ -1419,7 +1422,7 @@ void eul_to_quat(float quat[4], const float eul[3])
|
|||
quat[3] = cj * cs - sj * sc;
|
||||
}
|
||||
|
||||
void rotate_eul(float beul[3], const char axis, const float ang)
|
||||
void rotate_eul(float beul[3], const char axis, const float angle)
|
||||
{
|
||||
float eul[3], mat1[3][3], mat2[3][3], totmat[3][3];
|
||||
|
||||
|
|
@ -1427,13 +1430,13 @@ void rotate_eul(float beul[3], const char axis, const float ang)
|
|||
|
||||
eul[0] = eul[1] = eul[2] = 0.0f;
|
||||
if (axis == 'X') {
|
||||
eul[0] = ang;
|
||||
eul[0] = angle;
|
||||
}
|
||||
else if (axis == 'Y') {
|
||||
eul[1] = ang;
|
||||
eul[1] = angle;
|
||||
}
|
||||
else {
|
||||
eul[2] = ang;
|
||||
eul[2] = angle;
|
||||
}
|
||||
|
||||
eul_to_mat3(mat1, eul);
|
||||
|
|
@ -1789,23 +1792,23 @@ void mat3_to_compatible_eulO(float eul[3],
|
|||
void mat4_normalized_to_compatible_eulO(float eul[3],
|
||||
const float oldrot[3],
|
||||
const short order,
|
||||
const float m[4][4])
|
||||
const float mat[4][4])
|
||||
{
|
||||
float mat3[3][3];
|
||||
|
||||
/* for now, we'll just do this the slow way (i.e. copying matrices) */
|
||||
copy_m3_m4(mat3, m);
|
||||
copy_m3_m4(mat3, mat);
|
||||
mat3_normalized_to_compatible_eulO(eul, oldrot, order, mat3);
|
||||
}
|
||||
void mat4_to_compatible_eulO(float eul[3],
|
||||
const float oldrot[3],
|
||||
const short order,
|
||||
const float m[4][4])
|
||||
const float mat[4][4])
|
||||
{
|
||||
float mat3[3][3];
|
||||
|
||||
/* for now, we'll just do this the slow way (i.e. copying matrices) */
|
||||
copy_m3_m4(mat3, m);
|
||||
copy_m3_m4(mat3, mat);
|
||||
normalize_m3(mat3);
|
||||
mat3_normalized_to_compatible_eulO(eul, oldrot, order, mat3);
|
||||
}
|
||||
|
|
@ -1824,7 +1827,7 @@ void quat_to_compatible_eulO(float eul[3],
|
|||
/* rotate the given euler by the given angle on the specified axis */
|
||||
/* NOTE: is this safe to do with different axis orders? */
|
||||
|
||||
void rotate_eulO(float beul[3], const short order, char axis, float ang)
|
||||
void rotate_eulO(float beul[3], const short order, const char axis, const float angle)
|
||||
{
|
||||
float eul[3], mat1[3][3], mat2[3][3], totmat[3][3];
|
||||
|
||||
|
|
@ -1833,13 +1836,13 @@ void rotate_eulO(float beul[3], const short order, char axis, float ang)
|
|||
zero_v3(eul);
|
||||
|
||||
if (axis == 'X') {
|
||||
eul[0] = ang;
|
||||
eul[0] = angle;
|
||||
}
|
||||
else if (axis == 'Y') {
|
||||
eul[1] = ang;
|
||||
eul[1] = angle;
|
||||
}
|
||||
else {
|
||||
eul[2] = ang;
|
||||
eul[2] = angle;
|
||||
}
|
||||
|
||||
eulO_to_mat3(mat1, eul, order);
|
||||
|
|
|
|||
|
|
@ -1125,7 +1125,7 @@ float BLI_noise_cell(float x, float y, float z)
|
|||
return (2.0f * BLI_cellNoiseU(x, y, z) - 1.0f);
|
||||
}
|
||||
|
||||
void BLI_noise_cell_v3(float x, float y, float z, float ca[3])
|
||||
void BLI_noise_cell_v3(float x, float y, float z, float r_ca[3])
|
||||
{
|
||||
/* avoid precision issues on unit coordinates */
|
||||
x = (x + 0.000001f) * 1.00001f;
|
||||
|
|
@ -1136,9 +1136,9 @@ void BLI_noise_cell_v3(float x, float y, float z, float ca[3])
|
|||
int yi = (int)(floor(y));
|
||||
int zi = (int)(floor(z));
|
||||
const float *p = HASHPNT(xi, yi, zi);
|
||||
ca[0] = p[0];
|
||||
ca[1] = p[1];
|
||||
ca[2] = p[2];
|
||||
r_ca[0] = p[0];
|
||||
r_ca[1] = p[1];
|
||||
r_ca[2] = p[2];
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
|
|
|||
|
|
@ -183,9 +183,13 @@ void EDBM_project_snap_verts(struct bContext *C,
|
|||
|
||||
/* editmesh_automerge.c */
|
||||
|
||||
void EDBM_automerge(struct Object *ob, bool update, char hflag, float dist);
|
||||
void EDBM_automerge_and_split(
|
||||
struct Object *ob, bool split_edges, bool split_faces, bool update, char hflag, float dist);
|
||||
void EDBM_automerge(struct Object *obedit, bool update, char hflag, float dist);
|
||||
void EDBM_automerge_and_split(struct Object *obedit,
|
||||
bool split_edges,
|
||||
bool split_faces,
|
||||
bool update,
|
||||
char hflag,
|
||||
float dist);
|
||||
|
||||
/* editmesh_undo.c */
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue