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.

9 files changed, 315 insertions, 295 deletions

diff --git a/source/blender/blenlib/BLI_math_color.h b/source/blender/blenlib/BLI_math_color.h
index 6386a7f76f8..3aa2e35476d 100644
--- a/source/blender/blenlib/BLI_math_color.h
+++ b/source/blender/blenlib/BLI_math_color.h
@@ -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.
diff --git a/source/blender/blenlib/BLI_math_geom.h b/source/blender/blenlib/BLI_math_geom.h
index 93b413ab755..d056c42e019 100644
--- a/source/blender/blenlib/BLI_math_geom.h
+++ b/source/blender/blenlib/BLI_math_geom.h
@@ -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);
 
diff --git a/source/blender/blenlib/BLI_math_matrix.h b/source/blender/blenlib/BLI_math_matrix.h
index c2dafbe3a1a..15264dbe8b7 100644
--- a/source/blender/blenlib/BLI_math_matrix.h
+++ b/source/blender/blenlib/BLI_math_matrix.h
@@ -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)
diff --git a/source/blender/blenlib/BLI_math_rotation.h b/source/blender/blenlib/BLI_math_rotation.h
index b8ab74d95ff..d4b97b85134 100644
--- a/source/blender/blenlib/BLI_math_rotation.h
+++ b/source/blender/blenlib/BLI_math_rotation.h
@@ -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 rotate_eulO(float eul[3], short order, char axis, float angle);
+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 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);
diff --git a/source/blender/blenlib/BLI_math_vector.h b/source/blender/blenlib/BLI_math_vector.h
index 0b178064a4c..17fe25ec67b 100644
--- a/source/blender/blenlib/BLI_math_vector.h
+++ b/source/blender/blenlib/BLI_math_vector.h
@@ -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_relative(const float a[2], const float b[2], float limit, int max_ulps)
+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 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]);
diff --git a/source/blender/blenlib/BLI_string_utf8.h b/source/blender/blenlib/BLI_string_utf8.h
index 4c5cc3fd9c5..58c9ad23e4c 100644
--- a/source/blender/blenlib/BLI_string_utf8.h
+++ b/source/blender/blenlib/BLI_string_utf8.h
@@ -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);
 
 /**
diff --git a/source/blender/blenlib/intern/math_matrix.c b/source/blender/blenlib/intern/math_matrix.c
index fcd017b3082..dcf0166b4e7 100644
--- a/source/blender/blenlib/intern/math_matrix.c
+++ b/source/blender/blenlib/intern/math_matrix.c
@@ -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);
     }
   }
 }
diff --git a/source/blender/blenlib/intern/math_rotation.c b/source/blender/blenlib/intern/math_rotation.c
index ddfaadced60..2cf0e1b41ae 100644
--- a/source/blender/blenlib/intern/math_rotation.c
+++ b/source/blender/blenlib/intern/math_rotation.c
@@ -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);
diff --git a/source/blender/blenlib/intern/noise.c b/source/blender/blenlib/intern/noise.c
index c39a2b5a27e..3ec7c3f9804 100644
--- a/source/blender/blenlib/intern/noise.c
+++ b/source/blender/blenlib/intern/noise.c
@@ -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];
 }
 
 /** \} */