Merge branch 'master' into temp-sculpt-colors

9 files changed, 529 insertions, 522 deletions

diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c
index 8ed156a7e55..1aa2cec861c 100644
--- a/source/blender/python/mathutils/mathutils.c
+++ b/source/blender/python/mathutils/mathutils.c
@@ -92,47 +92,46 @@ Py_hash_t mathutils_array_hash(const float *array, size_t array_len)
 }
 
 int mathutils_array_parse(
-    float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
+    float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
 {
-  const uint flag = array_max;
-  int size;
+  const uint flag = array_num_max;
+  int num;
 
-  array_max &= ~MU_ARRAY_FLAGS;
+  array_num_max &= ~MU_ARRAY_FLAGS;
 
 #if 1 /* approx 6x speedup for mathutils types */
 
-  if ((size = VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) ||
-      (size = EulerObject_Check(value) ? 3 : 0) ||
-      (size = QuaternionObject_Check(value) ? 4 : 0) ||
-      (size = ColorObject_Check(value) ? 3 : 0)) {
+  if ((num = VectorObject_Check(value) ? ((VectorObject *)value)->vec_num : 0) ||
+      (num = EulerObject_Check(value) ? 3 : 0) || (num = QuaternionObject_Check(value) ? 4 : 0) ||
+      (num = ColorObject_Check(value) ? 3 : 0)) {
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
 
     if (flag & MU_ARRAY_SPILL) {
-      CLAMP_MAX(size, array_max);
+      CLAMP_MAX(num, array_num_max);
     }
 
-    if (size > array_max || size < array_min) {
-      if (array_max == array_min) {
+    if (num > array_num_max || num < array_num_min) {
+      if (array_num_max == array_num_min) {
         PyErr_Format(PyExc_ValueError,
-                     "%.200s: sequence size is %d, expected %d",
+                     "%.200s: sequence length is %d, expected %d",
                      error_prefix,
-                     size,
-                     array_max);
+                     num,
+                     array_num_max);
       }
       else {
         PyErr_Format(PyExc_ValueError,
-                     "%.200s: sequence size is %d, expected [%d - %d]",
+                     "%.200s: sequence length is %d, expected [%d - %d]",
                      error_prefix,
-                     size,
-                     array_min,
-                     array_max);
+                     num,
+                     array_num_min,
+                     array_num_max);
       }
       return -1;
     }
 
-    memcpy(array, ((const BaseMathObject *)value)->data, size * sizeof(float));
+    memcpy(array, ((const BaseMathObject *)value)->data, num * sizeof(float));
   }
   else
 #endif
@@ -145,77 +144,76 @@ int mathutils_array_parse(
       return -1;
     }
 
-    size = PySequence_Fast_GET_SIZE(value_fast);
+    num = PySequence_Fast_GET_SIZE(value_fast);
 
     if (flag & MU_ARRAY_SPILL) {
-      CLAMP_MAX(size, array_max);
+      CLAMP_MAX(num, array_num_max);
     }
 
-    if (size > array_max || size < array_min) {
-      if (array_max == array_min) {
+    if (num > array_num_max || num < array_num_min) {
+      if (array_num_max == array_num_min) {
         PyErr_Format(PyExc_ValueError,
-                     "%.200s: sequence size is %d, expected %d",
+                     "%.200s: sequence length is %d, expected %d",
                      error_prefix,
-                     size,
-                     array_max);
+                     num,
+                     array_num_max);
       }
       else {
         PyErr_Format(PyExc_ValueError,
-                     "%.200s: sequence size is %d, expected [%d - %d]",
+                     "%.200s: sequence length is %d, expected [%d - %d]",
                      error_prefix,
-                     size,
-                     array_min,
-                     array_max);
+                     num,
+                     array_num_min,
+                     array_num_max);
       }
       Py_DECREF(value_fast);
       return -1;
     }
 
-    size = mathutils_array_parse_fast(array, size, value_fast, error_prefix);
+    num = mathutils_array_parse_fast(array, num, value_fast, error_prefix);
     Py_DECREF(value_fast);
   }
 
-  if (size != -1) {
+  if (num != -1) {
     if (flag & MU_ARRAY_ZERO) {
-      const int size_left = array_max - size;
-      if (size_left) {
-        memset(&array[size], 0, sizeof(float) * size_left);
+      const int array_num_left = array_num_max - num;
+      if (array_num_left) {
+        memset(&array[num], 0, sizeof(float) * array_num_left);
       }
     }
   }
 
-  return size;
+  return num;
 }
 
 int mathutils_array_parse_alloc(float **array,
-                                int array_min,
+                                int array_num,
                                 PyObject *value,
                                 const char *error_prefix)
 {
-  int size;
+  int num;
 
 #if 1 /* approx 6x speedup for mathutils types */
 
-  if ((size = VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) ||
-      (size = EulerObject_Check(value) ? 3 : 0) ||
-      (size = QuaternionObject_Check(value) ? 4 : 0) ||
-      (size = ColorObject_Check(value) ? 3 : 0)) {
+  if ((num = VectorObject_Check(value) ? ((VectorObject *)value)->vec_num : 0) ||
+      (num = EulerObject_Check(value) ? 3 : 0) || (num = QuaternionObject_Check(value) ? 4 : 0) ||
+      (num = ColorObject_Check(value) ? 3 : 0)) {
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
 
-    if (size < array_min) {
+    if (num < array_num) {
       PyErr_Format(PyExc_ValueError,
                    "%.200s: sequence size is %d, expected > %d",
                    error_prefix,
-                   size,
-                   array_min);
+                   num,
+                   array_num);
       return -1;
     }
 
-    *array = PyMem_Malloc(size * sizeof(float));
-    memcpy(*array, ((const BaseMathObject *)value)->data, size * sizeof(float));
-    return size;
+    *array = PyMem_Malloc(num * sizeof(float));
+    memcpy(*array, ((const BaseMathObject *)value)->data, num * sizeof(float));
+    return num;
   }
 
 #endif
@@ -230,21 +228,21 @@ int mathutils_array_parse_alloc(float **array,
     return -1;
   }
 
-  size = PySequence_Fast_GET_SIZE(value_fast);
+  num = PySequence_Fast_GET_SIZE(value_fast);
 
-  if (size < array_min) {
+  if (num < array_num) {
     Py_DECREF(value_fast);
     PyErr_Format(PyExc_ValueError,
                  "%.200s: sequence size is %d, expected > %d",
                  error_prefix,
-                 size,
-                 array_min);
+                 num,
+                 array_num);
     return -1;
   }
 
-  *array = PyMem_Malloc(size * sizeof(float));
+  *array = PyMem_Malloc(num * sizeof(float));
 
-  ret = mathutils_array_parse_fast(*array, size, value_fast, error_prefix);
+  ret = mathutils_array_parse_fast(*array, num, value_fast, error_prefix);
   Py_DECREF(value_fast);
 
   if (ret == -1) {
@@ -261,7 +259,7 @@ int mathutils_array_parse_alloc_v(float **array,
 {
   PyObject *value_fast;
   const int array_dim_flag = array_dim;
-  int i, size;
+  int i, num;
 
   /* non list/tuple cases */
   if (!(value_fast = PySequence_Fast(value, error_prefix))) {
@@ -269,30 +267,30 @@ int mathutils_array_parse_alloc_v(float **array,
     return -1;
   }
 
-  size = PySequence_Fast_GET_SIZE(value_fast);
+  num = PySequence_Fast_GET_SIZE(value_fast);
 
-  if (size != 0) {
+  if (num != 0) {
     PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
     float *fp;
 
     array_dim &= ~MU_ARRAY_FLAGS;
 
-    fp = *array = PyMem_Malloc(size * array_dim * sizeof(float));
+    fp = *array = PyMem_Malloc(num * array_dim * sizeof(float));
 
-    for (i = 0; i < size; i++, fp += array_dim) {
+    for (i = 0; i < num; i++, fp += array_dim) {
       PyObject *item = value_fast_items[i];
 
       if (mathutils_array_parse(fp, array_dim, array_dim_flag, item, error_prefix) == -1) {
         PyMem_Free(*array);
         *array = NULL;
-        size = -1;
+        num = -1;
         break;
       }
     }
   }
 
   Py_DECREF(value_fast);
-  return size;
+  return num;
 }
 
 int mathutils_int_array_parse(int *array, int array_dim, PyObject *value, const char *error_prefix)
@@ -458,7 +456,7 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
-    if (((MatrixObject *)value)->num_row < 3 || ((MatrixObject *)value)->num_col < 3) {
+    if (((MatrixObject *)value)->row_num < 3 || ((MatrixObject *)value)->col_num < 3) {
       PyErr_Format(
           PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
       return -1;
diff --git a/source/blender/python/mathutils/mathutils.h b/source/blender/python/mathutils/mathutils.h
index 5831489ef5b..84386e99d18 100644
--- a/source/blender/python/mathutils/mathutils.h
+++ b/source/blender/python/mathutils/mathutils.h
@@ -153,12 +153,12 @@ void _BaseMathObject_RaiseNotFrozenExc(const BaseMathObject *self);
  * \return length of `value`, -1 on error.
  */
 int mathutils_array_parse(
-    float *array, int array_min, int array_max, PyObject *value, const char *error_prefix);
+    float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix);
 /**
  * \return -1 is returned on error and no allocation is made.
  */
 int mathutils_array_parse_alloc(float **array,
-                                int array_min,
+                                int array_num_min,
                                 PyObject *value,
                                 const char *error_prefix);
 /**
diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c
index b8eaf1486ab..76b5424711f 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.c
+++ b/source/blender/python/mathutils/mathutils_Matrix.c
@@ -34,7 +34,7 @@ static PyObject *MatrixAccess_CreatePyObject(MatrixObject *matrix, const eMatrix
 
 static int matrix_row_vector_check(MatrixObject *mat, VectorObject *vec, int row)
 {
-  if ((vec->size != mat->num_col) || (row >= mat->num_row)) {
+  if ((vec->vec_num != mat->col_num) || (row >= mat->row_num)) {
     PyErr_SetString(PyExc_AttributeError,
                     "Matrix(): "
                     "owner matrix has been resized since this row vector was created");
@@ -46,7 +46,7 @@ static int matrix_row_vector_check(MatrixObject *mat, VectorObject *vec, int row
 
 static int matrix_col_vector_check(MatrixObject *mat, VectorObject *vec, int col)
 {
-  if ((vec->size != mat->num_row) || (col >= mat->num_col)) {
+  if ((vec->vec_num != mat->row_num) || (col >= mat->col_num)) {
     PyErr_SetString(PyExc_AttributeError,
                     "Matrix(): "
                     "owner matrix has been resized since this column vector was created");
@@ -80,7 +80,7 @@ static int mathutils_matrix_row_get(BaseMathObject *bmo, int row)
     return -1;
   }
 
-  for (col = 0; col < self->num_col; col++) {
+  for (col = 0; col < self->col_num; col++) {
     bmo->data[col] = MATRIX_ITEM(self, row, col);
   }
 
@@ -99,7 +99,7 @@ static int mathutils_matrix_row_set(BaseMathObject *bmo, int row)
     return -1;
   }
 
-  for (col = 0; col < self->num_col; col++) {
+  for (col = 0; col < self->col_num; col++) {
     MATRIX_ITEM(self, row, col) = bmo->data[col];
   }
 
@@ -162,7 +162,7 @@ static int mathutils_matrix_col_check(BaseMathObject *bmo)
 static int mathutils_matrix_col_get(BaseMathObject *bmo, int col)
 {
   MatrixObject *self = (MatrixObject *)bmo->cb_user;
-  int num_row;
+  int row_num;
   int row;
 
   if (BaseMath_ReadCallback(self) == -1) {
@@ -172,10 +172,10 @@ static int mathutils_matrix_col_get(BaseMathObject *bmo, int col)
     return -1;
   }
 
-  /* for 'translation' size will always be '3' even on 4x4 vec */
-  num_row = min_ii(self->num_row, ((const VectorObject *)bmo)->size);
+  /* for 'translation' `vec_num` will always be '3' even on 4x4 vec */
+  row_num = min_ii(self->row_num, ((const VectorObject *)bmo)->vec_num);
 
-  for (row = 0; row < num_row; row++) {
+  for (row = 0; row < row_num; row++) {
     bmo->data[row] = MATRIX_ITEM(self, row, col);
   }
 
@@ -185,7 +185,7 @@ static int mathutils_matrix_col_get(BaseMathObject *bmo, int col)
 static int mathutils_matrix_col_set(BaseMathObject *bmo, int col)
 {
   MatrixObject *self = (MatrixObject *)bmo->cb_user;
-  int num_row;
+  int row_num;
   int row;
 
   if (BaseMath_ReadCallback_ForWrite(self) == -1) {
@@ -195,10 +195,10 @@ static int mathutils_matrix_col_set(BaseMathObject *bmo, int col)
     return -1;
   }
 
-  /* for 'translation' size will always be '3' even on 4x4 vec */
-  num_row = min_ii(self->num_row, ((const VectorObject *)bmo)->size);
+  /* for 'translation' `vec_num` will always be '3' even on 4x4 vec */
+  row_num = min_ii(self->row_num, ((const VectorObject *)bmo)->vec_num);
 
-  for (row = 0; row < num_row; row++) {
+  for (row = 0; row < row_num; row++) {
     MATRIX_ITEM(self, row, col) = bmo->data[row];
   }
 
@@ -349,18 +349,18 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
       /* Input is now as a sequence of rows so length of sequence
        * is the number of rows */
       /* -1 is an error, size checks will account for this */
-      const ushort num_row = PySequence_Size(arg);
+      const ushort row_num = PySequence_Size(arg);
 
-      if (num_row >= 2 && num_row <= 4) {
+      if (row_num >= 2 && row_num <= 4) {
         PyObject *item = PySequence_GetItem(arg, 0);
         /* Since each item is a row, number of items is the
          * same as the number of columns */
-        const ushort num_col = PySequence_Size(item);
+        const ushort col_num = PySequence_Size(item);
         Py_XDECREF(item);
 
-        if (num_col >= 2 && num_col <= 4) {
+        if (col_num >= 2 && col_num <= 4) {
           /* Sane row & col size, new matrix and assign as slice. */
-          PyObject *matrix = Matrix_CreatePyObject(NULL, num_col, num_row, type);
+          PyObject *matrix = Matrix_CreatePyObject(NULL, col_num, row_num, type);
           if (Matrix_ass_slice((MatrixObject *)matrix, 0, INT_MAX, arg) == 0) {
             return matrix;
           }
@@ -613,7 +613,7 @@ PyDoc_STRVAR(C_Matrix_Scale_doc,
 static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
 {
   PyObject *vec = NULL;
-  int vec_size;
+  int vec_num;
   float tvec[3];
   float factor;
   int matSize;
@@ -646,12 +646,10 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
     return NULL;
   }
   if (vec) {
-    vec_size = (matSize == 2 ? 2 : 3);
-    if (mathutils_array_parse(tvec,
-                              vec_size,
-                              vec_size,
-                              vec,
-                              "Matrix.Scale(factor, size, axis), invalid 'axis' arg") == -1) {
+    vec_num = (matSize == 2 ? 2 : 3);
+    if (mathutils_array_parse(
+            tvec, vec_num, vec_num, vec, "Matrix.Scale(factor, size, axis), invalid 'axis' arg") ==
+        -1) {
       return NULL;
     }
   }
@@ -671,11 +669,11 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
      * normalize arbitrary axis */
     float norm = 0.0f;
     int x;
-    for (x = 0; x < vec_size; x++) {
+    for (x = 0; x < vec_num; x++) {
       norm += tvec[x] * tvec[x];
     }
     norm = sqrtf(norm);
-    for (x = 0; x < vec_size; x++) {
+    for (x = 0; x < vec_num; x++) {
       tvec[x] /= norm;
     }
     if (matSize == 2) {
@@ -795,23 +793,23 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
   else {
     /* arbitrary plane */
 
-    const int vec_size = (matSize == 2 ? 2 : 3);
+    const int vec_num = (matSize == 2 ? 2 : 3);
     float tvec[4];
 
     if (mathutils_array_parse(tvec,
-                              vec_size,
-                              vec_size,
+                              vec_num,
+                              vec_num,
                               axis,
                               "Matrix.OrthoProjection(axis, size), invalid 'axis' arg") == -1) {
       return NULL;
     }
 
     /* normalize arbitrary axis */
-    for (x = 0; x < vec_size; x++) {
+    for (x = 0; x < vec_num; x++) {
       norm += tvec[x] * tvec[x];
     }
     norm = sqrtf(norm);
-    for (x = 0; x < vec_size; x++) {
+    for (x = 0; x < vec_num; x++) {
       tvec[x] /= norm;
     }
     if (matSize == 2) {
@@ -1019,7 +1017,7 @@ static PyObject *C_Matrix_LocRotScale(PyObject *cls, PyObject *args)
       return NULL;
     }
 
-    if (mat_obj->num_col == 3 && mat_obj->num_row == 3) {
+    if (mat_obj->col_num == 3 && mat_obj->row_num == 3) {
       copy_m4_m3(mat, (const float(*)[3])mat_obj->matrix);
     }
     else {
@@ -1062,20 +1060,20 @@ void matrix_as_3x3(float mat[3][3], MatrixObject *self)
 
 static void matrix_copy(MatrixObject *mat_dst, const MatrixObject *mat_src)
 {
-  BLI_assert((mat_dst->num_col == mat_src->num_col) && (mat_dst->num_row == mat_src->num_row));
+  BLI_assert((mat_dst->col_num == mat_src->col_num) && (mat_dst->row_num == mat_src->row_num));
   BLI_assert(mat_dst != mat_src);
 
-  memcpy(mat_dst->matrix, mat_src->matrix, sizeof(float) * (mat_dst->num_col * mat_dst->num_row));
+  memcpy(mat_dst->matrix, mat_src->matrix, sizeof(float) * (mat_dst->col_num * mat_dst->row_num));
 }
 
 static void matrix_unit_internal(MatrixObject *self)
 {
-  const int mat_size = sizeof(float) * (self->num_col * self->num_row);
+  const int mat_size = sizeof(float) * (self->col_num * self->row_num);
   memset(self->matrix, 0x0, mat_size);
-  const int col_row_max = min_ii(self->num_col, self->num_row);
-  const int num_row = self->num_row;
+  const int col_row_max = min_ii(self->col_num, self->row_num);
+  const int row_num = self->row_num;
   for (int col = 0; col < col_row_max; col++) {
-    self->matrix[(col * num_row) + col] = 1.0f;
+    self->matrix[(col * row_num) + col] = 1.0f;
   }
 }
 
@@ -1085,8 +1083,8 @@ static void matrix_transpose_internal(float mat_dst_fl[], const MatrixObject *ma
   ushort col, row;
   uint i = 0;
 
-  for (row = 0; row < mat_src->num_row; row++) {
-    for (col = 0; col < mat_src->num_col; col++) {
+  for (row = 0; row < mat_src->row_num; row++) {
+    for (col = 0; col < mat_src->col_num; col++) {
       mat_dst_fl[i++] = MATRIX_ITEM(mat_src, row, col);
     }
   }
@@ -1095,13 +1093,13 @@ static void matrix_transpose_internal(float mat_dst_fl[], const MatrixObject *ma
 /* assumes rowsize == colsize is checked and the read callback has run */
 static float matrix_determinant_internal(const MatrixObject *self)
 {
-  if (self->num_col == 2) {
+  if (self->col_num == 2) {
     return determinant_m2(MATRIX_ITEM(self, 0, 0),
                           MATRIX_ITEM(self, 0, 1),
                           MATRIX_ITEM(self, 1, 0),
                           MATRIX_ITEM(self, 1, 1));
   }
-  if (self->num_col == 3) {
+  if (self->col_num == 3) {
     return determinant_m3(MATRIX_ITEM(self, 0, 0),
                           MATRIX_ITEM(self, 0, 1),
                           MATRIX_ITEM(self, 0, 2),
@@ -1152,8 +1150,8 @@ static void matrix_invert_with_det_n_internal(float *mat_dst,
 
   /* divide by determinant & set values */
   k = 0;
-  for (i = 0; i < dim; i++) {   /* num_col */
-    for (j = 0; j < dim; j++) { /* num_row */
+  for (i = 0; i < dim; i++) {   /* col_num */
+    for (j = 0; j < dim; j++) { /* row_num */
       mat_dst[MATRIX_ITEM_INDEX_NUMROW(dim, j, i)] = mat[k++] / det;
     }
   }
@@ -1165,11 +1163,11 @@ static void matrix_invert_with_det_n_internal(float *mat_dst,
 static bool matrix_invert_internal(const MatrixObject *self, float *r_mat)
 {
   float det;
-  BLI_assert(self->num_col == self->num_row);
+  BLI_assert(self->col_num == self->row_num);
   det = matrix_determinant_internal(self);
 
   if (det != 0.0f) {
-    matrix_invert_with_det_n_internal(r_mat, self->matrix, det, self->num_col);
+    matrix_invert_with_det_n_internal(r_mat, self->matrix, det, self->col_num);
     return true;
   }
 
@@ -1184,7 +1182,7 @@ static void matrix_invert_safe_internal(const MatrixObject *self, float *r_mat)
 {
   float det;
   float *in_mat = self->matrix;
-  BLI_assert(self->num_col == self->num_row);
+  BLI_assert(self->col_num == self->row_num);
   det = matrix_determinant_internal(self);
 
   if (det == 0.0f) {
@@ -1194,7 +1192,7 @@ static void matrix_invert_safe_internal(const MatrixObject *self, float *r_mat)
      * and modify it in place to add diagonal epsilon. */
     in_mat = r_mat;
 
-    switch (self->num_col) {
+    switch (self->col_num) {
       case 2: {
         float(*mat)[2] = (float(*)[2])in_mat;
 
@@ -1248,7 +1246,7 @@ static void matrix_invert_safe_internal(const MatrixObject *self, float *r_mat)
     }
   }
 
-  matrix_invert_with_det_n_internal(r_mat, in_mat, det, self->num_col);
+  matrix_invert_with_det_n_internal(r_mat, in_mat, det, self->col_num);
 }
 
 /*-----------------------------METHODS----------------------------*/
@@ -1268,13 +1266,13 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
   }
 
   /* must be 3-4 cols, 3-4 rows, square matrix */
-  if ((self->num_row < 3) || (self->num_col < 3) || (self->num_row != self->num_col)) {
+  if ((self->row_num < 3) || (self->col_num < 3) || (self->row_num != self->col_num)) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.to_quat(): "
                     "inappropriate matrix size - expects 3x3 or 4x4 matrix");
     return NULL;
   }
-  if (self->num_row == 3) {
+  if (self->row_num == 3) {
     mat3_to_quat(quat, (float(*)[3])self->matrix);
   }
   else {
@@ -1326,10 +1324,10 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if (self->num_row == 3 && self->num_col == 3) {
+  if (self->row_num == 3 && self->col_num == 3) {
     copy_m3_m3(mat, (const float(*)[3])self->matrix);
   }
-  else if (self->num_row == 4 && self->num_col == 4) {
+  else if (self->row_num == 4 && self->col_num == 4) {
     copy_m3_m4(mat, (const float(*)[4])self->matrix);
   }
   else {
@@ -1401,36 +1399,36 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
 
   unit_m4(mat);
 
-  for (col = 0; col < self->num_col; col++) {
-    memcpy(mat[col], MATRIX_COL_PTR(self, col), self->num_row * sizeof(float));
+  for (col = 0; col < self->col_num; col++) {
+    memcpy(mat[col], MATRIX_COL_PTR(self, col), self->row_num * sizeof(float));
   }
 
   copy_m4_m4((float(*)[4])self->matrix, (const float(*)[4])mat);
 
-  self->num_col = 4;
-  self->num_row = 4;
+  self->col_num = 4;
+  self->row_num = 4;
 
   Py_RETURN_NONE;
 }
 
-static PyObject *Matrix_to_NxN(MatrixObject *self, const int num_col, const int num_row)
+static PyObject *Matrix_to_NxN(MatrixObject *self, const int col_num, const int row_num)
 {
-  const int mat_size = sizeof(float) * (num_col * num_row);
+  const int mat_size = sizeof(float) * (col_num * row_num);
   MatrixObject *pymat = (MatrixObject *)Matrix_CreatePyObject_alloc(
-      PyMem_Malloc(mat_size), num_col, num_row, Py_TYPE(self));
+      PyMem_Malloc(mat_size), col_num, row_num, Py_TYPE(self));
 
-  if ((self->num_row == num_row) && (self->num_col == num_col)) {
+  if ((self->row_num == row_num) && (self->col_num == col_num)) {
     memcpy(pymat->matrix, self->matrix, mat_size);
   }
   else {
-    if ((self->num_col < num_col) || (self->num_row < num_row)) {
+    if ((self->col_num < col_num) || (self->row_num < row_num)) {
       matrix_unit_internal(pymat);
     }
-    const int col_len_src = min_ii(num_col, self->num_col);
-    const int row_len_src = min_ii(num_row, self->num_row);
+    const int col_len_src = min_ii(col_num, self->col_num);
+    const int row_len_src = min_ii(row_num, self->row_num);
     for (int col = 0; col < col_len_src; col++) {
       memcpy(
-          &pymat->matrix[col * num_row], MATRIX_COL_PTR(self, col), sizeof(float) * row_len_src);
+          &pymat->matrix[col * row_num], MATRIX_COL_PTR(self, col), sizeof(float) * row_len_src);
     }
   }
   return (PyObject *)pymat;
@@ -1495,7 +1493,7 @@ static PyObject *Matrix_to_translation(MatrixObject *self)
     return NULL;
   }
 
-  if ((self->num_row < 3) || self->num_col < 4) {
+  if ((self->row_num < 3) || self->col_num < 4) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.to_translation(): "
                     "inappropriate matrix size");
@@ -1526,7 +1524,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if ((self->num_row < 3) || (self->num_col < 3)) {
+  if ((self->row_num < 3) || (self->col_num < 3)) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.to_scale(): "
                     "inappropriate matrix size, 3x3 minimum size");
@@ -1546,7 +1544,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
 /* re-usable checks for invert */
 static bool matrix_invert_is_compat(const MatrixObject *self)
 {
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.invert(ed): "
                     "only square matrices are supported");
@@ -1571,7 +1569,7 @@ static bool matrix_invert_args_check(const MatrixObject *self, PyObject *args, b
           return false;
         }
 
-        if ((self->num_col != fallback->num_col) || (self->num_row != fallback->num_row)) {
+        if ((self->col_num != fallback->col_num) || (self->row_num != fallback->row_num)) {
           PyErr_SetString(PyExc_TypeError,
                           "Matrix.invert: "
                           "matrix argument has different dimensions");
@@ -1782,7 +1780,7 @@ static PyObject *Matrix_adjugate(MatrixObject *self)
     return NULL;
   }
 
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.adjugate(d): "
                     "only square matrices are supported");
@@ -1790,12 +1788,12 @@ static PyObject *Matrix_adjugate(MatrixObject *self)
   }
 
   /* calculate the classical adjoint */
-  if (self->num_col <= 4) {
-    adjoint_matrix_n(self->matrix, self->matrix, self->num_col);
+  if (self->col_num <= 4) {
+    adjoint_matrix_n(self->matrix, self->matrix, self->col_num);
   }
   else {
     PyErr_Format(
-        PyExc_ValueError, "Matrix adjugate(d): size (%d) unsupported", (int)self->num_col);
+        PyExc_ValueError, "Matrix adjugate(d): size (%d) unsupported", (int)self->col_num);
     return NULL;
   }
 
@@ -1838,7 +1836,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
     return NULL;
   }
 
-  if (self->num_row != 3 || self->num_col != 3) {
+  if (self->row_num != 3 || self->col_num != 3) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.rotate(): "
                     "must have 3x3 dimensions");
@@ -1870,7 +1868,7 @@ static PyObject *Matrix_decompose(MatrixObject *self)
   float quat[4];
   float size[3];
 
-  if (self->num_row != 4 || self->num_col != 4) {
+  if (self->row_num != 4 || self->col_num != 4) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.decompose(): "
                     "inappropriate matrix size - expects 4x4 matrix");
@@ -1913,7 +1911,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
     return NULL;
   }
 
-  if (self->num_col != mat2->num_col || self->num_row != mat2->num_row) {
+  if (self->col_num != mat2->col_num || self->row_num != mat2->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.lerp(): "
                     "expects both matrix objects of the same dimensions");
@@ -1925,14 +1923,14 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
   }
 
   /* TODO: different sized matrix. */
-  if (self->num_col == 4 && self->num_row == 4) {
+  if (self->col_num == 4 && self->row_num == 4) {
 #ifdef MATH_STANDALONE
     blend_m4_m4m4((float(*)[4])mat, (float(*)[4])self->matrix, (float(*)[4])mat2->matrix, fac);
 #else
     interp_m4_m4m4((float(*)[4])mat, (float(*)[4])self->matrix, (float(*)[4])mat2->matrix, fac);
 #endif
   }
-  else if (self->num_col == 3 && self->num_row == 3) {
+  else if (self->col_num == 3 && self->row_num == 3) {
 #ifdef MATH_STANDALONE
     blend_m3_m3m3((float(*)[3])mat, (float(*)[3])self->matrix, (float(*)[3])mat2->matrix, fac);
 #else
@@ -1946,7 +1944,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
     return NULL;
   }
 
-  return Matrix_CreatePyObject(mat, self->num_col, self->num_row, Py_TYPE(self));
+  return Matrix_CreatePyObject(mat, self->col_num, self->row_num, Py_TYPE(self));
 }
 
 /*---------------------------matrix.determinant() ----------------*/
@@ -1966,7 +1964,7 @@ static PyObject *Matrix_determinant(MatrixObject *self)
     return NULL;
   }
 
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.determinant(): "
                     "only square matrices are supported");
@@ -1989,19 +1987,19 @@ static PyObject *Matrix_transpose(MatrixObject *self)
     return NULL;
   }
 
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.transpose(d): "
                     "only square matrices are supported");
     return NULL;
   }
 
-  if (self->num_col == 2) {
+  if (self->col_num == 2) {
     const float t = MATRIX_ITEM(self, 1, 0);
     MATRIX_ITEM(self, 1, 0) = MATRIX_ITEM(self, 0, 1);
     MATRIX_ITEM(self, 0, 1) = t;
   }
-  else if (self->num_col == 3) {
+  else if (self->col_num == 3) {
     transpose_m3((float(*)[3])self->matrix);
   }
   else {
@@ -2035,17 +2033,17 @@ static PyObject *Matrix_normalize(MatrixObject *self)
     return NULL;
   }
 
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.normalize(): "
                     "only square matrices are supported");
     return NULL;
   }
 
-  if (self->num_col == 3) {
+  if (self->col_num == 3) {
     normalize_m3((float(*)[3])self->matrix);
   }
-  else if (self->num_col == 4) {
+  else if (self->col_num == 4) {
     normalize_m4((float(*)[4])self->matrix);
   }
   else {
@@ -2083,7 +2081,7 @@ static PyObject *Matrix_zero(MatrixObject *self)
     return NULL;
   }
 
-  copy_vn_fl(self->matrix, self->num_col * self->num_row, 0.0f);
+  copy_vn_fl(self->matrix, self->col_num * self->row_num, 0.0f);
 
   if (BaseMath_WriteCallback(self) == -1) {
     return NULL;
@@ -2094,12 +2092,12 @@ static PyObject *Matrix_zero(MatrixObject *self)
 /*---------------------------matrix.identity(() ------------------*/
 static void matrix_identity_internal(MatrixObject *self)
 {
-  BLI_assert((self->num_col == self->num_row) && (self->num_row <= 4));
+  BLI_assert((self->col_num == self->row_num) && (self->row_num <= 4));
 
-  if (self->num_col == 2) {
+  if (self->col_num == 2) {
     unit_m2((float(*)[2])self->matrix);
   }
-  else if (self->num_col == 3) {
+  else if (self->col_num == 3) {
     unit_m3((float(*)[3])self->matrix);
   }
   else {
@@ -2123,7 +2121,7 @@ static PyObject *Matrix_identity(MatrixObject *self)
     return NULL;
   }
 
-  if (self->num_col != self->num_row) {
+  if (self->col_num != self->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix.identity(): "
                     "only square matrices are supported");
@@ -2143,7 +2141,7 @@ static PyObject *Matrix_identity(MatrixObject *self)
 
 static PyObject *Matrix_copy_notest(MatrixObject *self, const float *matrix)
 {
-  return Matrix_CreatePyObject((const float *)matrix, self->num_col, self->num_row, Py_TYPE(self));
+  return Matrix_CreatePyObject((const float *)matrix, self->col_num, self->row_num, Py_TYPE(self));
 }
 
 PyDoc_STRVAR(Matrix_copy_doc,
@@ -2180,13 +2178,13 @@ static PyObject *Matrix_repr(MatrixObject *self)
     return NULL;
   }
 
-  for (row = 0; row < self->num_row; row++) {
-    rows[row] = PyTuple_New(self->num_col);
-    for (col = 0; col < self->num_col; col++) {
+  for (row = 0; row < self->row_num; row++) {
+    rows[row] = PyTuple_New(self->col_num);
+    for (col = 0; col < self->col_num; col++) {
       PyTuple_SET_ITEM(rows[row], col, PyFloat_FromDouble(MATRIX_ITEM(self, row, col)));
     }
   }
-  switch (self->num_row) {
+  switch (self->row_num) {
     case 2:
       return PyUnicode_FromFormat(
           "Matrix((%R,\n"
@@ -2236,9 +2234,9 @@ static PyObject *Matrix_str(MatrixObject *self)
   ds = BLI_dynstr_new();
 
   /* First determine the maximum width for each column */
-  for (col = 0; col < self->num_col; col++) {
+  for (col = 0; col < self->col_num; col++) {
     maxsize[col] = 0;
-    for (row = 0; row < self->num_row; row++) {
+    for (row = 0; row < self->row_num; row++) {
       const int size = BLI_snprintf_rlen(
           dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col));
       maxsize[col] = max_ii(maxsize[col], size);
@@ -2246,12 +2244,12 @@ static PyObject *Matrix_str(MatrixObject *self)
   }
 
   /* Now write the unicode string to be printed */
-  BLI_dynstr_appendf(ds, "<Matrix %dx%d (", self->num_row, self->num_col);
-  for (row = 0; row < self->num_row; row++) {
-    for (col = 0; col < self->num_col; col++) {
+  BLI_dynstr_appendf(ds, "<Matrix %dx%d (", self->row_num, self->col_num);
+  for (row = 0; row < self->row_num; row++) {
+    for (col = 0; col < self->col_num; col++) {
       BLI_dynstr_appendf(ds, col ? ", %*.4f" : "%*.4f", maxsize[col], MATRIX_ITEM(self, row, col));
     }
-    BLI_dynstr_append(ds, row + 1 != self->num_row ? ")\n            (" : ")");
+    BLI_dynstr_append(ds, row + 1 != self->row_num ? ")\n            (" : ")");
   }
   BLI_dynstr_append(ds, ">");
 
@@ -2272,8 +2270,8 @@ static PyObject *Matrix_richcmpr(PyObject *a, PyObject *b, int op)
       return NULL;
     }
 
-    ok = ((matA->num_row == matB->num_row) && (matA->num_col == matB->num_col) &&
-          EXPP_VectorsAreEqual(matA->matrix, matB->matrix, (matA->num_col * matA->num_row), 1)) ?
+    ok = ((matA->row_num == matB->row_num) && (matA->col_num == matB->col_num) &&
+          EXPP_VectorsAreEqual(matA->matrix, matB->matrix, (matA->col_num * matA->row_num), 1)) ?
              0 :
              -1;
   }
@@ -2314,7 +2312,7 @@ static Py_hash_t Matrix_hash(MatrixObject *self)
 
   matrix_transpose_internal(mat, self);
 
-  return mathutils_array_hash(mat, self->num_row * self->num_col);
+  return mathutils_array_hash(mat, self->row_num * self->col_num);
 }
 
 /*---------------------SEQUENCE PROTOCOLS------------------------
@@ -2322,7 +2320,7 @@ static Py_hash_t Matrix_hash(MatrixObject *self)
  * sequence length */
 static int Matrix_len(MatrixObject *self)
 {
-  return self->num_row;
+  return self->row_num;
 }
 /*----------------------------object[]---------------------------
  * sequence accessor (get)
@@ -2333,14 +2331,14 @@ static PyObject *Matrix_item_row(MatrixObject *self, int row)
     return NULL;
   }
 
-  if (row < 0 || row >= self->num_row) {
+  if (row < 0 || row >= self->row_num) {
     PyErr_SetString(PyExc_IndexError,
                     "matrix[attribute]: "
                     "array index out of range");
     return NULL;
   }
   return Vector_CreatePyObject_cb(
-      (PyObject *)self, self->num_col, mathutils_matrix_row_cb_index, row);
+      (PyObject *)self, self->col_num, mathutils_matrix_row_cb_index, row);
 }
 /* same but column access */
 static PyObject *Matrix_item_col(MatrixObject *self, int col)
@@ -2349,14 +2347,14 @@ static PyObject *Matrix_item_col(MatrixObject *self, int col)
     return NULL;
   }
 
-  if (col < 0 || col >= self->num_col) {
+  if (col < 0 || col >= self->col_num) {
     PyErr_SetString(PyExc_IndexError,
                     "matrix[attribute]: "
                     "array index out of range");
     return NULL;
   }
   return Vector_CreatePyObject_cb(
-      (PyObject *)self, self->num_row, mathutils_matrix_col_cb_index, col);
+      (PyObject *)self, self->row_num, mathutils_matrix_col_cb_index, col);
 }
 
 /*----------------------------object[]-------------------------
@@ -2370,18 +2368,18 @@ static int Matrix_ass_item_row(MatrixObject *self, int row, PyObject *value)
     return -1;
   }
 
-  if (row >= self->num_row || row < 0) {
+  if (row >= self->row_num || row < 0) {
     PyErr_SetString(PyExc_IndexError, "matrix[attribute] = x: bad row");
     return -1;
   }
 
   if (mathutils_array_parse(
-          vec, self->num_col, self->num_col, value, "matrix[i] = value assignment") == -1) {
+          vec, self->col_num, self->col_num, value, "matrix[i] = value assignment") == -1) {
     return -1;
   }
 
   /* Since we are assigning a row we cannot memcpy */
-  for (col = 0; col < self->num_col; col++) {
+  for (col = 0; col < self->col_num; col++) {
     MATRIX_ITEM(self, row, col) = vec[col];
   }
 
@@ -2396,18 +2394,18 @@ static int Matrix_ass_item_col(MatrixObject *self, int col, PyObject *value)
     return -1;
   }
 
-  if (col >= self->num_col || col < 0) {
+  if (col >= self->col_num || col < 0) {
     PyErr_SetString(PyExc_IndexError, "matrix[attribute] = x: bad col");
     return -1;
   }
 
   if (mathutils_array_parse(
-          vec, self->num_row, self->num_row, value, "matrix[i] = value assignment") == -1) {
+          vec, self->row_num, self->row_num, value, "matrix[i] = value assignment") == -1) {
     return -1;
   }
 
   /* Since we are assigning a row we cannot memcpy */
-  for (row = 0; row < self->num_row; row++) {
+  for (row = 0; row < self->row_num; row++) {
     MATRIX_ITEM(self, row, col) = vec[row];
   }
 
@@ -2427,8 +2425,8 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
     return NULL;
   }
 
-  CLAMP(begin, 0, self->num_row);
-  CLAMP(end, 0, self->num_row);
+  CLAMP(begin, 0, self->row_num);
+  CLAMP(end, 0, self->row_num);
   begin = MIN2(begin, end);
 
   tuple = PyTuple_New(end - begin);
@@ -2436,7 +2434,7 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
     PyTuple_SET_ITEM(tuple,
                      count - begin,
                      Vector_CreatePyObject_cb(
-                         (PyObject *)self, self->num_col, mathutils_matrix_row_cb_index, count));
+                         (PyObject *)self, self->col_num, mathutils_matrix_row_cb_index, count));
   }
 
   return tuple;
@@ -2451,8 +2449,8 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
     return -1;
   }
 
-  CLAMP(begin, 0, self->num_row);
-  CLAMP(end, 0, self->num_row);
+  CLAMP(begin, 0, self->row_num);
+  CLAMP(end, 0, self->row_num);
   begin = MIN2(begin, end);
 
   /* non list/tuple cases */
@@ -2475,7 +2473,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
     return -1;
   }
 
-  memcpy(mat, self->matrix, self->num_col * self->num_row * sizeof(float));
+  memcpy(mat, self->matrix, self->col_num * self->row_num * sizeof(float));
 
   /* parse sub items */
   for (row = begin; row < end; row++) {
@@ -2483,21 +2481,21 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
     PyObject *item = value_fast_items[row - begin];
 
     if (mathutils_array_parse(
-            vec, self->num_col, self->num_col, item, "matrix[begin:end] = value assignment") ==
+            vec, self->col_num, self->col_num, item, "matrix[begin:end] = value assignment") ==
         -1) {
       Py_DECREF(value_fast);
       return -1;
     }
 
-    for (col = 0; col < self->num_col; col++) {
-      mat[col * self->num_row + row] = vec[col];
+    for (col = 0; col < self->col_num; col++) {
+      mat[col * self->row_num + row] = vec[col];
     }
   }
 
   Py_DECREF(value_fast);
 
   /* Parsed well - now set in matrix. */
-  memcpy(self->matrix, mat, self->num_col * self->num_row * sizeof(float));
+  memcpy(self->matrix, mat, self->col_num * self->row_num * sizeof(float));
 
   (void)BaseMath_WriteCallback(self);
   return 0;
@@ -2525,16 +2523,16 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
     return NULL;
   }
 
-  if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) {
+  if (mat1->col_num != mat2->col_num || mat1->row_num != mat2->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix addition: "
                     "matrices must have the same dimensions for this operation");
     return NULL;
   }
 
-  add_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
+  add_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->col_num * mat1->row_num);
 
-  return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_TYPE(mat1));
+  return Matrix_CreatePyObject(mat, mat1->col_num, mat1->row_num, Py_TYPE(mat1));
 }
 /*------------------------obj - obj------------------------------
  * subtraction */
@@ -2559,24 +2557,24 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
     return NULL;
   }
 
-  if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) {
+  if (mat1->col_num != mat2->col_num || mat1->row_num != mat2->row_num) {
     PyErr_SetString(PyExc_ValueError,
                     "Matrix addition: "
                     "matrices must have the same dimensions for this operation");
     return NULL;
   }
 
-  sub_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
+  sub_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->col_num * mat1->row_num);
 
-  return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_TYPE(mat1));
+  return Matrix_CreatePyObject(mat, mat1->col_num, mat1->row_num, Py_TYPE(mat1));
 }
 /*------------------------obj * obj------------------------------
  * element-wise multiplication */
 static PyObject *matrix_mul_float(MatrixObject *mat, const float scalar)
 {
   float tmat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
-  mul_vn_vn_fl(tmat, mat->matrix, mat->num_col * mat->num_row, scalar);
-  return Matrix_CreatePyObject(tmat, mat->num_col, mat->num_row, Py_TYPE(mat));
+  mul_vn_vn_fl(tmat, mat->matrix, mat->col_num * mat->row_num, scalar);
+  return Matrix_CreatePyObject(tmat, mat->col_num, mat->row_num, Py_TYPE(mat));
 }
 
 static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
@@ -2602,16 +2600,16 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
     /* MATRIX * MATRIX */
     float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
 
-    if ((mat1->num_row != mat2->num_row) || (mat1->num_col != mat2->num_col)) {
+    if ((mat1->row_num != mat2->row_num) || (mat1->col_num != mat2->col_num)) {
       PyErr_SetString(PyExc_ValueError,
                       "matrix1 * matrix2: matrix1 number of rows/columns "
                       "and the matrix2 number of rows/columns must be the same");
       return NULL;
     }
 
-    mul_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
+    mul_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->col_num * mat1->row_num);
 
-    return Matrix_CreatePyObject(mat, mat2->num_col, mat1->num_row, Py_TYPE(mat1));
+    return Matrix_CreatePyObject(mat, mat2->col_num, mat1->row_num, Py_TYPE(mat1));
   }
   if (mat2) {
     /* FLOAT/INT * MATRIX */
@@ -2656,18 +2654,18 @@ static PyObject *Matrix_imul(PyObject *m1, PyObject *m2)
 
   if (mat1 && mat2) {
     /* MATRIX *= MATRIX */
-    if ((mat1->num_row != mat2->num_row) || (mat1->num_col != mat2->num_col)) {
+    if ((mat1->row_num != mat2->row_num) || (mat1->col_num != mat2->col_num)) {
       PyErr_SetString(PyExc_ValueError,
                       "matrix1 *= matrix2: matrix1 number of rows/columns "
                       "and the matrix2 number of rows/columns must be the same");
       return NULL;
     }
 
-    mul_vn_vn(mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
+    mul_vn_vn(mat1->matrix, mat2->matrix, mat1->col_num * mat1->row_num);
   }
   else if (mat1 && (((scalar = PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred()) == 0)) {
     /* MATRIX *= FLOAT/INT */
-    mul_vn_fl(mat1->matrix, mat1->num_row * mat1->num_col, scalar);
+    mul_vn_fl(mat1->matrix, mat1->row_num * mat1->col_num, scalar);
   }
   else {
     PyErr_Format(PyExc_TypeError,
@@ -2686,7 +2684,7 @@ static PyObject *Matrix_imul(PyObject *m1, PyObject *m2)
  * matrix multiplication */
 static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2)
 {
-  int vec_size;
+  int vec_num;
 
   MatrixObject *mat1 = NULL, *mat2 = NULL;
 
@@ -2709,24 +2707,24 @@ static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2)
 
     int col, row, item;
 
-    if (mat1->num_col != mat2->num_row) {
+    if (mat1->col_num != mat2->row_num) {
       PyErr_SetString(PyExc_ValueError,
                       "matrix1 * matrix2: matrix1 number of columns "
                       "and the matrix2 number of rows must be the same");
       return NULL;
     }
 
-    for (col = 0; col < mat2->num_col; col++) {
-      for (row = 0; row < mat1->num_row; row++) {
+    for (col = 0; col < mat2->col_num; col++) {
+      for (row = 0; row < mat1->row_num; row++) {
         double dot = 0.0f;
-        for (item = 0; item < mat1->num_col; item++) {
+        for (item = 0; item < mat1->col_num; item++) {
           dot += (double)(MATRIX_ITEM(mat1, row, item) * MATRIX_ITEM(mat2, item, col));
         }
-        mat[(col * mat1->num_row) + row] = (float)dot;
+        mat[(col * mat1->row_num) + row] = (float)dot;
       }
     }
 
-    return Matrix_CreatePyObject(mat, mat2->num_col, mat1->num_row, Py_TYPE(mat1));
+    return Matrix_CreatePyObject(mat, mat2->col_num, mat1->row_num, Py_TYPE(mat1));
   }
   if (mat1) {
     /* MATRIX @ VECTOR */
@@ -2740,14 +2738,14 @@ static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2)
         return NULL;
       }
 
-      if (mat1->num_col == 4 && vec2->size == 3) {
-        vec_size = 3;
+      if (mat1->col_num == 4 && vec2->vec_num == 3) {
+        vec_num = 3;
       }
       else {
-        vec_size = mat1->num_row;
+        vec_num = mat1->row_num;
       }
 
-      return Vector_CreatePyObject(tvec, vec_size, Py_TYPE(m2));
+      return Vector_CreatePyObject(tvec, vec_num, Py_TYPE(m2));
     }
   }
 
@@ -2782,27 +2780,27 @@ static PyObject *Matrix_imatmul(PyObject *m1, PyObject *m2)
     float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
     int col, row, item;
 
-    if (mat1->num_col != mat2->num_row) {
+    if (mat1->col_num != mat2->row_num) {
       PyErr_SetString(PyExc_ValueError,
                       "matrix1 * matrix2: matrix1 number of columns "
                       "and the matrix2 number of rows must be the same");
       return NULL;
     }
 
-    for (col = 0; col < mat2->num_col; col++) {
-      for (row = 0; row < mat1->num_row; row++) {
+    for (col = 0; col < mat2->col_num; col++) {
+      for (row = 0; row < mat1->row_num; row++) {
         double dot = 0.0f;
-        for (item = 0; item < mat1->num_col; item++) {
+        for (item = 0; item < mat1->col_num; item++) {
           dot += (double)(MATRIX_ITEM(mat1, row, item) * MATRIX_ITEM(mat2, item, col));
         }
         /* store in new matrix as overwriting original at this point will cause
          * subsequent iterations to use incorrect values */
-        mat[(col * mat1->num_row) + row] = (float)dot;
+        mat[(col * mat1->row_num) + row] = (float)dot;
       }
     }
 
     /* copy matrix back */
-    memcpy(mat1->matrix, mat, (mat1->num_row * mat1->num_col) * sizeof(float));
+    memcpy(mat1->matrix, mat, (mat1->row_num * mat1->col_num) * sizeof(float));
   }
   else {
     PyErr_Format(PyExc_TypeError,
@@ -2841,14 +2839,14 @@ static PyObject *Matrix_subscript(MatrixObject *self, PyObject *item)
       return NULL;
     }
     if (i < 0) {
-      i += self->num_row;
+      i += self->row_num;
     }
     return Matrix_item_row(self, i);
   }
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
-    if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) {
+    if (PySlice_GetIndicesEx(item, self->row_num, &start, &stop, &step, &slicelength) < 0) {
       return NULL;
     }
 
@@ -2876,14 +2874,14 @@ static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *va
       return -1;
     }
     if (i < 0) {
-      i += self->num_row;
+      i += self->row_num;
     }
     return Matrix_ass_item_row(self, i, value);
   }
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
-    if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) {
+    if (PySlice_GetIndicesEx(item, self->row_num, &start, &stop, &step, &slicelength) < 0) {
       return -1;
     }
 
@@ -2955,7 +2953,7 @@ static PyObject *Matrix_translation_get(MatrixObject *self, void *UNUSED(closure
   }
 
   /* Must be 4x4 square matrix. */
-  if (self->num_row != 4 || self->num_col != 4) {
+  if (self->row_num != 4 || self->col_num != 4) {
     PyErr_SetString(PyExc_AttributeError,
                     "Matrix.translation: "
                     "inappropriate matrix size, must be 4x4");
@@ -2977,7 +2975,7 @@ static int Matrix_translation_set(MatrixObject *self, PyObject *value, void *UNU
   }
 
   /* Must be 4x4 square matrix. */
-  if (self->num_row != 4 || self->num_col != 4) {
+  if (self->row_num != 4 || self->col_num != 4) {
     PyErr_SetString(PyExc_AttributeError,
                     "Matrix.translation: "
                     "inappropriate matrix size, must be 4x4");
@@ -3021,7 +3019,7 @@ static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closur
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if ((self->num_row < 3) || (self->num_col < 3)) {
+  if ((self->row_num < 3) || (self->col_num < 3)) {
     PyErr_SetString(PyExc_AttributeError,
                     "Matrix.median_scale: "
                     "inappropriate matrix size, 3x3 minimum");
@@ -3043,10 +3041,10 @@ static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if (self->num_row == 4 && self->num_col == 4) {
+  if (self->row_num == 4 && self->col_num == 4) {
     return PyBool_FromLong(is_negative_m4((const float(*)[4])self->matrix));
   }
-  if (self->num_row == 3 && self->num_col == 3) {
+  if (self->row_num == 3 && self->col_num == 3) {
     return PyBool_FromLong(is_negative_m3((const float(*)[3])self->matrix));
   }
 
@@ -3065,10 +3063,10 @@ static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closu
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if (self->num_row == 4 && self->num_col == 4) {
+  if (self->row_num == 4 && self->col_num == 4) {
     return PyBool_FromLong(is_orthonormal_m4((const float(*)[4])self->matrix));
   }
-  if (self->num_row == 3 && self->num_col == 3) {
+  if (self->row_num == 3 && self->col_num == 3) {
     return PyBool_FromLong(is_orthonormal_m3((const float(*)[3])self->matrix));
   }
 
@@ -3088,10 +3086,10 @@ static PyObject *Matrix_is_orthogonal_axis_vectors_get(MatrixObject *self, void
   }
 
   /* Must be 3-4 cols, 3-4 rows, square matrix. */
-  if (self->num_row == 4 && self->num_col == 4) {
+  if (self->row_num == 4 && self->col_num == 4) {
     return PyBool_FromLong(is_orthogonal_m4((const float(*)[4])self->matrix));
   }
-  if (self->num_row == 3 && self->num_col == 3) {
+  if (self->row_num == 3 && self->col_num == 3) {
     return PyBool_FromLong(is_orthogonal_m3((const float(*)[3])self->matrix));
   }
 
@@ -3271,22 +3269,22 @@ PyTypeObject matrix_Type = {
 };
 
 PyObject *Matrix_CreatePyObject(const float *mat,
-                                const ushort num_col,
-                                const ushort num_row,
+                                const ushort col_num,
+                                const ushort row_num,
                                 PyTypeObject *base_type)
 {
   MatrixObject *self;
   float *mat_alloc;
 
   /* matrix objects can be any 2-4row x 2-4col matrix */
-  if (num_col < 2 || num_col > 4 || num_row < 2 || num_row > 4) {
+  if (col_num < 2 || col_num > 4 || row_num < 2 || row_num > 4) {
     PyErr_SetString(PyExc_RuntimeError,
                     "Matrix(): "
                     "row and column sizes must be between 2 and 4");
     return NULL;
   }
 
-  mat_alloc = PyMem_Malloc(num_col * num_row * sizeof(float));
+  mat_alloc = PyMem_Malloc(col_num * row_num * sizeof(float));
   if (UNLIKELY(mat_alloc == NULL)) {
     PyErr_SetString(PyExc_MemoryError,
                     "Matrix(): "
@@ -3297,23 +3295,23 @@ PyObject *Matrix_CreatePyObject(const float *mat,
   self = BASE_MATH_NEW(MatrixObject, matrix_Type, base_type);
   if (self) {
     self->matrix = mat_alloc;
-    self->num_col = num_col;
-    self->num_row = num_row;
+    self->col_num = col_num;
+    self->row_num = row_num;
 
     /* init callbacks as NULL */
     self->cb_user = NULL;
     self->cb_type = self->cb_subtype = 0;
 
     if (mat) { /* If a float array passed. */
-      memcpy(self->matrix, mat, num_col * num_row * sizeof(float));
+      memcpy(self->matrix, mat, col_num * row_num * sizeof(float));
     }
-    else if (num_col == num_row) {
+    else if (col_num == row_num) {
       /* or if no arguments are passed return identity matrix for square matrices */
       matrix_identity_internal(self);
     }
     else {
       /* otherwise zero everything */
-      memset(self->matrix, 0, num_col * num_row * sizeof(float));
+      memset(self->matrix, 0, col_num * row_num * sizeof(float));
     }
     self->flag = BASE_MATH_FLAG_DEFAULT;
   }
@@ -3325,14 +3323,14 @@ PyObject *Matrix_CreatePyObject(const float *mat,
 }
 
 PyObject *Matrix_CreatePyObject_wrap(float *mat,
-                                     const ushort num_col,
-                                     const ushort num_row,
+                                     const ushort col_num,
+                                     const ushort row_num,
                                      PyTypeObject *base_type)
 {
   MatrixObject *self;
 
   /* matrix objects can be any 2-4row x 2-4col matrix */
-  if (num_col < 2 || num_col > 4 || num_row < 2 || num_row > 4) {
+  if (col_num < 2 || col_num > 4 || row_num < 2 || row_num > 4) {
     PyErr_SetString(PyExc_RuntimeError,
                     "Matrix(): "
                     "row and column sizes must be between 2 and 4");
@@ -3341,8 +3339,8 @@ PyObject *Matrix_CreatePyObject_wrap(float *mat,
 
   self = BASE_MATH_NEW(MatrixObject, matrix_Type, base_type);
   if (self) {
-    self->num_col = num_col;
-    self->num_row = num_row;
+    self->col_num = col_num;
+    self->row_num = row_num;
 
     /* init callbacks as NULL */
     self->cb_user = NULL;
@@ -3355,9 +3353,9 @@ PyObject *Matrix_CreatePyObject_wrap(float *mat,
 }
 
 PyObject *Matrix_CreatePyObject_cb(
-    PyObject *cb_user, const ushort num_col, const ushort num_row, uchar cb_type, uchar cb_subtype)
+    PyObject *cb_user, const ushort col_num, const ushort row_num, uchar cb_type, uchar cb_subtype)
 {
-  MatrixObject *self = (MatrixObject *)Matrix_CreatePyObject(NULL, num_col, num_row, NULL);
+  MatrixObject *self = (MatrixObject *)Matrix_CreatePyObject(NULL, col_num, row_num, NULL);
   if (self) {
     Py_INCREF(cb_user);
     self->cb_user = cb_user;
@@ -3369,12 +3367,12 @@ PyObject *Matrix_CreatePyObject_cb(
 }
 
 PyObject *Matrix_CreatePyObject_alloc(float *mat,
-                                      const ushort num_col,
-                                      const ushort num_row,
+                                      const ushort col_num,
+                                      const ushort row_num,
                                       PyTypeObject *base_type)
 {
   MatrixObject *self;
-  self = (MatrixObject *)Matrix_CreatePyObject_wrap(mat, num_col, num_row, base_type);
+  self = (MatrixObject *)Matrix_CreatePyObject_wrap(mat, col_num, row_num, base_type);
   if (self) {
     self->flag &= ~BASE_MATH_FLAG_IS_WRAP;
   }
@@ -3419,7 +3417,7 @@ int Matrix_Parse2x2(PyObject *o, void *p)
   if (!Matrix_ParseCheck(pymat)) {
     return 0;
   }
-  if ((pymat->num_col != 2) || (pymat->num_row != 2)) {
+  if ((pymat->col_num != 2) || (pymat->row_num != 2)) {
     PyErr_SetString(PyExc_ValueError, "matrix must be 2x2");
     return 0;
   }
@@ -3436,7 +3434,7 @@ int Matrix_Parse3x3(PyObject *o, void *p)
   if (!Matrix_ParseCheck(pymat)) {
     return 0;
   }
-  if ((pymat->num_col != 3) || (pymat->num_row != 3)) {
+  if ((pymat->col_num != 3) || (pymat->row_num != 3)) {
     PyErr_SetString(PyExc_ValueError, "matrix must be 3x3");
     return 0;
   }
@@ -3453,7 +3451,7 @@ int Matrix_Parse4x4(PyObject *o, void *p)
   if (!Matrix_ParseCheck(pymat)) {
     return 0;
   }
-  if ((pymat->num_col != 4) || (pymat->num_row != 4)) {
+  if ((pymat->col_num != 4) || (pymat->row_num != 4)) {
     PyErr_SetString(PyExc_ValueError, "matrix must be 4x4");
     return 0;
   }
@@ -3497,7 +3495,7 @@ static void MatrixAccess_dealloc(MatrixAccessObject *self)
 
 static int MatrixAccess_len(MatrixAccessObject *self)
 {
-  return (self->type == MAT_ACCESS_ROW) ? self->matrix_user->num_row : self->matrix_user->num_col;
+  return (self->type == MAT_ACCESS_ROW) ? self->matrix_user->row_num : self->matrix_user->col_num;
 }
 
 static PyObject *MatrixAccess_slice(MatrixAccessObject *self, int begin, int end)
@@ -3511,11 +3509,11 @@ static PyObject *MatrixAccess_slice(MatrixAccessObject *self, int begin, int end
   PyObject *(*Matrix_item_new)(MatrixObject *, int);
 
   if (self->type == MAT_ACCESS_ROW) {
-    matrix_access_len = matrix_user->num_row;
+    matrix_access_len = matrix_user->row_num;
     Matrix_item_new = Matrix_item_row;
   }
   else { /* MAT_ACCESS_ROW */
-    matrix_access_len = matrix_user->num_col;
+    matrix_access_len = matrix_user->col_num;
     Matrix_item_new = Matrix_item_col;
   }
 
@@ -3546,13 +3544,13 @@ static PyObject *MatrixAccess_subscript(MatrixAccessObject *self, PyObject *item
     }
     if (self->type == MAT_ACCESS_ROW) {
       if (i < 0) {
-        i += matrix_user->num_row;
+        i += matrix_user->row_num;
       }
       return Matrix_item_row(matrix_user, i);
     }
     /* MAT_ACCESS_ROW */
     if (i < 0) {
-      i += matrix_user->num_col;
+      i += matrix_user->col_num;
     }
     return Matrix_item_col(matrix_user, i);
   }
@@ -3592,13 +3590,13 @@ static int MatrixAccess_ass_subscript(MatrixAccessObject *self, PyObject *item,
 
     if (self->type == MAT_ACCESS_ROW) {
       if (i < 0) {
-        i += matrix_user->num_row;
+        i += matrix_user->row_num;
       }
       return Matrix_ass_item_row(matrix_user, i, value);
     }
     /* MAT_ACCESS_ROW */
     if (i < 0) {
-      i += matrix_user->num_col;
+      i += matrix_user->col_num;
     }
     return Matrix_ass_item_col(matrix_user, i, value);
   }
diff --git a/source/blender/python/mathutils/mathutils_Matrix.h b/source/blender/python/mathutils/mathutils_Matrix.h
index 6dd1640b3bf..bc596ce6ac8 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.h
+++ b/source/blender/python/mathutils/mathutils_Matrix.h
@@ -20,14 +20,14 @@ typedef unsigned short ushort;
 
 #ifdef DEBUG
 #  define MATRIX_ITEM_ASSERT(_mat, _row, _col) \
-    (BLI_assert(_row < (_mat)->num_row && _col < (_mat)->num_col))
+    (BLI_assert(_row < (_mat)->row_num && _col < (_mat)->col_num))
 #else
 #  define MATRIX_ITEM_ASSERT(_mat, _row, _col) (void)0
 #endif
 
 #define MATRIX_ITEM_INDEX_NUMROW(_totrow, _row, _col) (((_totrow) * (_col)) + (_row))
 #define MATRIX_ITEM_INDEX(_mat, _row, _col) \
-  (MATRIX_ITEM_ASSERT(_mat, _row, _col), (((_mat)->num_row * (_col)) + (_row)))
+  (MATRIX_ITEM_ASSERT(_mat, _row, _col), (((_mat)->row_num * (_col)) + (_row)))
 #define MATRIX_ITEM_PTR(_mat, _row, _col) ((_mat)->matrix + MATRIX_ITEM_INDEX(_mat, _row, _col))
 #define MATRIX_ITEM(_mat, _row, _col) ((_mat)->matrix[MATRIX_ITEM_INDEX(_mat, _row, _col)])
 
@@ -36,8 +36,8 @@ typedef unsigned short ushort;
 
 typedef struct {
   BASE_MATH_MEMBERS(matrix);
-  ushort num_col;
-  ushort num_row;
+  ushort col_num;
+  ushort row_num;
 } MatrixObject;
 
 /* struct data contains a pointer to the actual data that the
@@ -47,17 +47,17 @@ typedef struct {
 
 /* prototypes */
 PyObject *Matrix_CreatePyObject(const float *mat,
-                                ushort num_col,
-                                ushort num_row,
+                                ushort col_num,
+                                ushort row_num,
                                 PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT;
 PyObject *Matrix_CreatePyObject_wrap(float *mat,
-                                     ushort num_col,
-                                     ushort num_row,
+                                     ushort col_num,
+                                     ushort row_num,
                                      PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL(1);
 PyObject *Matrix_CreatePyObject_cb(PyObject *user,
-                                   unsigned short num_col,
-                                   unsigned short num_row,
+                                   unsigned short col_num,
+                                   unsigned short row_num,
                                    unsigned char cb_type,
                                    unsigned char cb_subtype) ATTR_WARN_UNUSED_RESULT;
 
@@ -65,8 +65,8 @@ PyObject *Matrix_CreatePyObject_cb(PyObject *user,
  * \param mat: Initialized matrix value to use in-place, allocated with #PyMem_Malloc
  */
 PyObject *Matrix_CreatePyObject_alloc(float *mat,
-                                      ushort num_col,
-                                      ushort num_row,
+                                      ushort col_num,
+                                      ushort row_num,
                                       PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT;
 
 /* PyArg_ParseTuple's "O&" formatting helpers. */
diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c
index f0ba125e768..7b51154f0d0 100644
--- a/source/blender/python/mathutils/mathutils_Quaternion.c
+++ b/source/blender/python/mathutils/mathutils_Quaternion.c
@@ -1035,7 +1035,7 @@ static PyObject *Quaternion_matmul(PyObject *q1, PyObject *q2)
       VectorObject *vec2 = (VectorObject *)q2;
       float tvec[3];
 
-      if (vec2->size != 3) {
+      if (vec2->vec_num != 3) {
         PyErr_SetString(PyExc_ValueError,
                         "Vector multiplication: "
                         "only 3D vector rotations (with quats) "
diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c
index 080a1e7fbdd..ffeb121b3d1 100644
--- a/source/blender/python/mathutils/mathutils_Vector.c
+++ b/source/blender/python/mathutils/mathutils_Vector.c
@@ -45,7 +45,7 @@ static int row_vector_multiplication(float r_vec[MAX_DIMENSIONS],
 static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
   float *vec = NULL;
-  int size = 3; /* default to a 3D vector */
+  int vec_num = 3; /* default to a 3D vector */
 
   if (kwds && PyDict_Size(kwds)) {
     PyErr_SetString(PyExc_TypeError,
@@ -56,7 +56,7 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 
   switch (PyTuple_GET_SIZE(args)) {
     case 0:
-      vec = PyMem_Malloc(size * sizeof(float));
+      vec = PyMem_Malloc(vec_num * sizeof(float));
 
       if (vec == NULL) {
         PyErr_SetString(PyExc_MemoryError,
@@ -65,10 +65,10 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
       }
 
-      copy_vn_fl(vec, size, 0.0f);
+      copy_vn_fl(vec, vec_num, 0.0f);
       break;
     case 1:
-      if ((size = mathutils_array_parse_alloc(
+      if ((vec_num = mathutils_array_parse_alloc(
                &vec, 2, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1) {
         return NULL;
       }
@@ -79,7 +79,7 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
                       "more than a single arg given");
       return NULL;
   }
-  return Vector_CreatePyObject_alloc(vec, size, type);
+  return Vector_CreatePyObject_alloc(vec, vec_num, type);
 }
 
 static PyObject *vec__apply_to_copy(PyObject *(*vec_func)(VectorObject *), VectorObject *self)
@@ -108,19 +108,19 @@ PyDoc_STRVAR(C_Vector_Fill_doc,
 static PyObject *C_Vector_Fill(PyObject *cls, PyObject *args)
 {
   float *vec;
-  int size;
+  int vec_num;
   float fill = 0.0f;
 
-  if (!PyArg_ParseTuple(args, "i|f:Vector.Fill", &size, &fill)) {
+  if (!PyArg_ParseTuple(args, "i|f:Vector.Fill", &vec_num, &fill)) {
     return NULL;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
     return NULL;
   }
 
-  vec = PyMem_Malloc(size * sizeof(float));
+  vec = PyMem_Malloc(vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
@@ -129,9 +129,9 @@ static PyObject *C_Vector_Fill(PyObject *cls, PyObject *args)
     return NULL;
   }
 
-  copy_vn_fl(vec, size, fill);
+  copy_vn_fl(vec, vec_num, fill);
 
-  return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
+  return Vector_CreatePyObject_alloc(vec, vec_num, (PyTypeObject *)cls);
 }
 
 PyDoc_STRVAR(C_Vector_Range_doc,
@@ -148,7 +148,7 @@ PyDoc_STRVAR(C_Vector_Range_doc,
 static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
 {
   float *vec;
-  int stop, size;
+  int stop, vec_num;
   int start = 0;
   int step = 1;
 
@@ -158,7 +158,7 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
 
   switch (PyTuple_GET_SIZE(args)) {
     case 1:
-      size = start;
+      vec_num = start;
       start = 0;
       break;
     case 2:
@@ -169,7 +169,7 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
         return NULL;
       }
 
-      size = stop - start;
+      vec_num = stop - start;
       break;
     default:
       if (start >= stop) {
@@ -179,23 +179,23 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
         return NULL;
       }
 
-      size = (stop - start);
+      vec_num = (stop - start);
 
-      if ((size % step) != 0) {
-        size += step;
+      if ((vec_num % step) != 0) {
+        vec_num += step;
       }
 
-      size /= step;
+      vec_num /= step;
 
       break;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
     return NULL;
   }
 
-  vec = PyMem_Malloc(size * sizeof(float));
+  vec = PyMem_Malloc(vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
@@ -204,9 +204,9 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
     return NULL;
   }
 
-  range_vn_fl(vec, size, (float)start, (float)step);
+  range_vn_fl(vec, vec_num, (float)start, (float)step);
 
-  return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
+  return Vector_CreatePyObject_alloc(vec, vec_num, (PyTypeObject *)cls);
 }
 
 PyDoc_STRVAR(C_Vector_Linspace_doc,
@@ -224,21 +224,21 @@ PyDoc_STRVAR(C_Vector_Linspace_doc,
 static PyObject *C_Vector_Linspace(PyObject *cls, PyObject *args)
 {
   float *vec;
-  int size;
+  int vec_num;
   float start, end, step;
 
-  if (!PyArg_ParseTuple(args, "ffi:Vector.Linspace", &start, &end, &size)) {
+  if (!PyArg_ParseTuple(args, "ffi:Vector.Linspace", &start, &end, &vec_num)) {
     return NULL;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector.Linspace(): invalid size");
     return NULL;
   }
 
-  step = (end - start) / (float)(size - 1);
+  step = (end - start) / (float)(vec_num - 1);
 
-  vec = PyMem_Malloc(size * sizeof(float));
+  vec = PyMem_Malloc(vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
@@ -247,9 +247,9 @@ static PyObject *C_Vector_Linspace(PyObject *cls, PyObject *args)
     return NULL;
   }
 
-  range_vn_fl(vec, size, start, step);
+  range_vn_fl(vec, vec_num, start, step);
 
-  return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
+  return Vector_CreatePyObject_alloc(vec, vec_num, (PyTypeObject *)cls);
 }
 
 PyDoc_STRVAR(
@@ -266,20 +266,20 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
 {
   float *vec;
   float *iter_vec = NULL;
-  int i, size, value_size;
+  int i, vec_num, value_num;
   PyObject *value;
 
-  if (!PyArg_ParseTuple(args, "Oi:Vector.Repeat", &value, &size)) {
+  if (!PyArg_ParseTuple(args, "Oi:Vector.Repeat", &value, &vec_num)) {
     return NULL;
   }
 
-  if (size < 2) {
-    PyErr_SetString(PyExc_RuntimeError, "Vector.Repeat(): invalid size");
+  if (vec_num < 2) {
+    PyErr_SetString(PyExc_RuntimeError, "Vector.Repeat(): invalid vec_num");
     return NULL;
   }
 
-  if ((value_size = mathutils_array_parse_alloc(
-           &iter_vec, 2, value, "Vector.Repeat(vector, size), invalid 'vector' arg")) == -1) {
+  if ((value_num = mathutils_array_parse_alloc(
+           &iter_vec, 2, value, "Vector.Repeat(vector, vec_num), invalid 'vector' arg")) == -1) {
     return NULL;
   }
 
@@ -290,7 +290,7 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
     return NULL;
   }
 
-  vec = PyMem_Malloc(size * sizeof(float));
+  vec = PyMem_Malloc(vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyMem_Free(iter_vec);
@@ -301,14 +301,14 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
   }
 
   i = 0;
-  while (i < size) {
-    vec[i] = iter_vec[i % value_size];
+  while (i < vec_num) {
+    vec[i] = iter_vec[i % value_num];
     i++;
   }
 
   PyMem_Free(iter_vec);
 
-  return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
+  return Vector_CreatePyObject_alloc(vec, vec_num, (PyTypeObject *)cls);
 }
 
 /*-----------------------------METHODS---------------------------- */
@@ -322,7 +322,7 @@ static PyObject *Vector_zero(VectorObject *self)
     return NULL;
   }
 
-  copy_vn_fl(self->vec, self->size, 0.0f);
+  copy_vn_fl(self->vec, self->vec_num, 0.0f);
 
   if (BaseMath_WriteCallback(self) == -1) {
     return NULL;
@@ -342,12 +342,12 @@ PyDoc_STRVAR(Vector_normalize_doc,
              "      however 4D Vectors w axis is left untouched.\n");
 static PyObject *Vector_normalize(VectorObject *self)
 {
-  const int size = (self->size == 4 ? 3 : self->size);
+  const int vec_num = (self->vec_num == 4 ? 3 : self->vec_num);
   if (BaseMath_ReadCallback_ForWrite(self) == -1) {
     return NULL;
   }
 
-  normalize_vn(self->vec, size);
+  normalize_vn(self->vec, vec_num);
 
   (void)BaseMath_WriteCallback(self);
   Py_RETURN_NONE;
@@ -370,7 +370,7 @@ PyDoc_STRVAR(Vector_resize_doc,
              "   Resize the vector to have size number of elements.\n");
 static PyObject *Vector_resize(VectorObject *self, PyObject *value)
 {
-  int size;
+  int vec_num;
 
   if (self->flag & BASE_MATH_FLAG_IS_WRAP) {
     PyErr_SetString(PyExc_TypeError,
@@ -385,19 +385,19 @@ static PyObject *Vector_resize(VectorObject *self, PyObject *value)
     return NULL;
   }
 
-  if ((size = PyC_Long_AsI32(value)) == -1) {
+  if ((vec_num = PyC_Long_AsI32(value)) == -1) {
     PyErr_SetString(PyExc_TypeError,
                     "Vector.resize(size): "
                     "expected size argument to be an integer");
     return NULL;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector.resize(): invalid size");
     return NULL;
   }
 
-  self->vec = PyMem_Realloc(self->vec, (size * sizeof(float)));
+  self->vec = PyMem_Realloc(self->vec, (vec_num * sizeof(float)));
   if (self->vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
                     "Vector.resize(): "
@@ -406,11 +406,11 @@ static PyObject *Vector_resize(VectorObject *self, PyObject *value)
   }
 
   /* If the vector has increased in length, set all new elements to 0.0f */
-  if (size > self->size) {
-    copy_vn_fl(self->vec + self->size, size - self->size, 0.0f);
+  if (vec_num > self->vec_num) {
+    copy_vn_fl(self->vec + self->vec_num, vec_num - self->vec_num, 0.0f);
   }
 
-  self->size = size;
+  self->vec_num = vec_num;
   Py_RETURN_NONE;
 }
 
@@ -423,19 +423,19 @@ PyDoc_STRVAR(Vector_resized_doc,
              "   :rtype: :class:`Vector`\n");
 static PyObject *Vector_resized(VectorObject *self, PyObject *value)
 {
-  int size;
+  int vec_num;
   float *vec;
 
-  if ((size = PyLong_AsLong(value)) == -1) {
+  if ((vec_num = PyLong_AsLong(value)) == -1) {
     return NULL;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector.resized(): invalid size");
     return NULL;
   }
 
-  vec = PyMem_Malloc(size * sizeof(float));
+  vec = PyMem_Malloc(vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
@@ -444,10 +444,10 @@ static PyObject *Vector_resized(VectorObject *self, PyObject *value)
     return NULL;
   }
 
-  copy_vn_fl(vec, size, 0.0f);
-  memcpy(vec, self->vec, self->size * sizeof(float));
+  copy_vn_fl(vec, vec_num, 0.0f);
+  memcpy(vec, self->vec, self->vec_num * sizeof(float));
 
-  return Vector_CreatePyObject_alloc(vec, size, NULL);
+  return Vector_CreatePyObject_alloc(vec, vec_num, NULL);
 }
 
 PyDoc_STRVAR(Vector_resize_2d_doc,
@@ -477,7 +477,7 @@ static PyObject *Vector_resize_2d(VectorObject *self)
     return NULL;
   }
 
-  self->size = 2;
+  self->vec_num = 2;
   Py_RETURN_NONE;
 }
 
@@ -508,11 +508,11 @@ static PyObject *Vector_resize_3d(VectorObject *self)
     return NULL;
   }
 
-  if (self->size == 2) {
+  if (self->vec_num == 2) {
     self->vec[2] = 0.0f;
   }
 
-  self->size = 3;
+  self->vec_num = 3;
   Py_RETURN_NONE;
 }
 
@@ -543,14 +543,14 @@ static PyObject *Vector_resize_4d(VectorObject *self)
     return NULL;
   }
 
-  if (self->size == 2) {
+  if (self->vec_num == 2) {
     self->vec[2] = 0.0f;
     self->vec[3] = 1.0f;
   }
-  else if (self->size == 3) {
+  else if (self->vec_num == 3) {
     self->vec[3] = 1.0f;
   }
-  self->size = 4;
+  self->vec_num = 4;
   Py_RETURN_NONE;
 }
 PyDoc_STRVAR(Vector_to_2d_doc,
@@ -583,7 +583,7 @@ static PyObject *Vector_to_3d(VectorObject *self)
     return NULL;
   }
 
-  memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 3));
+  memcpy(tvec, self->vec, sizeof(float) * MIN2(self->vec_num, 3));
   return Vector_CreatePyObject(tvec, 3, Py_TYPE(self));
 }
 PyDoc_STRVAR(Vector_to_4d_doc,
@@ -601,7 +601,7 @@ static PyObject *Vector_to_4d(VectorObject *self)
     return NULL;
   }
 
-  memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 4));
+  memcpy(tvec, self->vec, sizeof(float) * MIN2(self->vec_num, 4));
   return Vector_CreatePyObject(tvec, 4, Py_TYPE(self));
 }
 
@@ -620,15 +620,15 @@ static PyObject *Vector_to_tuple_ex(VectorObject *self, int ndigits)
   PyObject *ret;
   int i;
 
-  ret = PyTuple_New(self->size);
+  ret = PyTuple_New(self->vec_num);
 
   if (ndigits >= 0) {
-    for (i = 0; i < self->size; i++) {
+    for (i = 0; i < self->vec_num; i++) {
       PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->vec[i], ndigits)));
     }
   }
   else {
-    for (i = 0; i < self->size; i++) {
+    for (i = 0; i < self->vec_num; i++) {
       PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->vec[i]));
     }
   }
@@ -684,7 +684,7 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
     return NULL;
   }
 
-  if (self->size != 3) {
+  if (self->vec_num != 3) {
     PyErr_SetString(PyExc_TypeError,
                     "Vector.to_track_quat(): "
                     "only for 3D vectors");
@@ -795,7 +795,7 @@ static PyObject *Vector_orthogonal(VectorObject *self)
 {
   float vec[3];
 
-  if (self->size > 3) {
+  if (self->vec_num > 3) {
     PyErr_SetString(PyExc_TypeError,
                     "Vector.orthogonal(): "
                     "Vector must be 3D or 2D");
@@ -806,14 +806,14 @@ static PyObject *Vector_orthogonal(VectorObject *self)
     return NULL;
   }
 
-  if (self->size == 3) {
+  if (self->vec_num == 3) {
     ortho_v3_v3(vec, self->vec);
   }
   else {
     ortho_v2_v2(vec, self->vec);
   }
 
-  return Vector_CreatePyObject(vec, self->size, Py_TYPE(self));
+  return Vector_CreatePyObject(vec, self->vec_num, Py_TYPE(self));
 }
 
 /**
@@ -833,7 +833,7 @@ PyDoc_STRVAR(Vector_reflect_doc,
              "   :rtype: :class:`Vector`\n");
 static PyObject *Vector_reflect(VectorObject *self, PyObject *value)
 {
-  int value_size;
+  int value_num;
   float mirror[3], vec[3];
   float reflect[3] = {0.0f};
   float tvec[MAX_DIMENSIONS];
@@ -842,28 +842,28 @@ static PyObject *Vector_reflect(VectorObject *self, PyObject *value)
     return NULL;
   }
 
-  if ((value_size = mathutils_array_parse(
+  if ((value_num = mathutils_array_parse(
            tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1) {
     return NULL;
   }
 
-  if (self->size < 2 || self->size > 4) {
+  if (self->vec_num < 2 || self->vec_num > 4) {
     PyErr_SetString(PyExc_ValueError, "Vector must be 2D, 3D or 4D");
     return NULL;
   }
 
   mirror[0] = tvec[0];
   mirror[1] = tvec[1];
-  mirror[2] = (value_size > 2) ? tvec[2] : 0.0f;
+  mirror[2] = (value_num > 2) ? tvec[2] : 0.0f;
 
   vec[0] = self->vec[0];
   vec[1] = self->vec[1];
-  vec[2] = (value_size > 2) ? self->vec[2] : 0.0f;
+  vec[2] = (value_num > 2) ? self->vec[2] : 0.0f;
 
   normalize_v3(mirror);
   reflect_v3_v3v3(reflect, vec, mirror);
 
-  return Vector_CreatePyObject(reflect, self->size, Py_TYPE(self));
+  return Vector_CreatePyObject(reflect, self->vec_num, Py_TYPE(self));
 }
 
 PyDoc_STRVAR(Vector_cross_doc,
@@ -886,17 +886,18 @@ static PyObject *Vector_cross(VectorObject *self, PyObject *value)
     return NULL;
   }
 
-  if (self->size > 3) {
+  if (self->vec_num > 3) {
     PyErr_SetString(PyExc_ValueError, "Vector must be 2D or 3D");
     return NULL;
   }
 
   if (mathutils_array_parse(
-          tvec, self->size, self->size, value, "Vector.cross(other), invalid 'other' arg") == -1) {
+          tvec, self->vec_num, self->vec_num, value, "Vector.cross(other), invalid 'other' arg") ==
+      -1) {
     return NULL;
   }
 
-  if (self->size == 3) {
+  if (self->vec_num == 3) {
     ret = Vector_CreatePyObject(NULL, 3, Py_TYPE(self));
     cross_v3_v3v3(((VectorObject *)ret)->vec, self->vec, tvec);
   }
@@ -926,11 +927,11 @@ static PyObject *Vector_dot(VectorObject *self, PyObject *value)
   }
 
   if (mathutils_array_parse_alloc(
-          &tvec, self->size, value, "Vector.dot(other), invalid 'other' arg") == -1) {
+          &tvec, self->vec_num, value, "Vector.dot(other), invalid 'other' arg") == -1) {
     return NULL;
   }
 
-  ret = PyFloat_FromDouble(dot_vn_vn(self->vec, tvec, self->size));
+  ret = PyFloat_FromDouble(dot_vn_vn(self->vec, tvec, self->vec_num));
   PyMem_Free(tvec);
   return ret;
 }
@@ -950,7 +951,7 @@ PyDoc_STRVAR(
     "   :rtype: float\n");
 static PyObject *Vector_angle(VectorObject *self, PyObject *args)
 {
-  const int size = MIN2(self->size, 3); /* 4D angle makes no sense */
+  const int vec_num = MIN2(self->vec_num, 3); /* 4D angle makes no sense */
   float tvec[MAX_DIMENSIONS];
   PyObject *value;
   double dot = 0.0f, dot_self = 0.0f, dot_other = 0.0f;
@@ -968,16 +969,17 @@ static PyObject *Vector_angle(VectorObject *self, PyObject *args)
   /* don't use clamped size, rule of thumb is vector sizes must match,
    * even though n this case 'w' is ignored */
   if (mathutils_array_parse(
-          tvec, self->size, self->size, value, "Vector.angle(other), invalid 'other' arg") == -1) {
+          tvec, self->vec_num, self->vec_num, value, "Vector.angle(other), invalid 'other' arg") ==
+      -1) {
     return NULL;
   }
 
-  if (self->size > 4) {
+  if (self->vec_num > 4) {
     PyErr_SetString(PyExc_ValueError, "Vector must be 2D, 3D or 4D");
     return NULL;
   }
 
-  for (x = 0; x < size; x++) {
+  for (x = 0; x < vec_num; x++) {
     dot_self += (double)self->vec[x] * (double)self->vec[x];
     dot_other += (double)tvec[x] * (double)tvec[x];
     dot += (double)self->vec[x] * (double)tvec[x];
@@ -1032,7 +1034,7 @@ static PyObject *Vector_angle_signed(VectorObject *self, PyObject *args)
     return NULL;
   }
 
-  if (self->size != 2) {
+  if (self->vec_num != 2) {
     PyErr_SetString(PyExc_ValueError, "Vector must be 2D");
     return NULL;
   }
@@ -1069,7 +1071,7 @@ static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value)
 {
   float quat[4], vec_a[3], vec_b[3];
 
-  if (self->size < 3 || self->size > 4) {
+  if (self->vec_num < 3 || self->vec_num > 4) {
     PyErr_SetString(PyExc_ValueError,
                     "vec.difference(value): "
                     "expects both vectors to be size 3 or 4");
@@ -1105,7 +1107,7 @@ PyDoc_STRVAR(Vector_project_doc,
              "   :rtype: :class:`Vector`\n");
 static PyObject *Vector_project(VectorObject *self, PyObject *value)
 {
-  const int size = self->size;
+  const int vec_num = self->vec_num;
   float *tvec;
   double dot = 0.0f, dot2 = 0.0f;
   int x;
@@ -1115,21 +1117,21 @@ static PyObject *Vector_project(VectorObject *self, PyObject *value)
   }
 
   if (mathutils_array_parse_alloc(
-          &tvec, size, value, "Vector.project(other), invalid 'other' arg") == -1) {
+          &tvec, vec_num, value, "Vector.project(other), invalid 'other' arg") == -1) {
     return NULL;
   }
 
   /* get dot products */
-  for (x = 0; x < size; x++) {
+  for (x = 0; x < vec_num; x++) {
     dot += (double)(self->vec[x] * tvec[x]);
     dot2 += (double)(tvec[x] * tvec[x]);
   }
   /* projection */
   dot /= dot2;
-  for (x = 0; x < size; x++) {
+  for (x = 0; x < vec_num; x++) {
     tvec[x] *= (float)dot;
   }
-  return Vector_CreatePyObject_alloc(tvec, size, Py_TYPE(self));
+  return Vector_CreatePyObject_alloc(tvec, vec_num, Py_TYPE(self));
 }
 
 PyDoc_STRVAR(Vector_lerp_doc,
@@ -1145,7 +1147,7 @@ PyDoc_STRVAR(Vector_lerp_doc,
              "   :rtype: :class:`Vector`\n");
 static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
 {
-  const int size = self->size;
+  const int vec_num = self->vec_num;
   PyObject *value = NULL;
   float fac;
   float *tvec;
@@ -1158,14 +1160,14 @@ static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
     return NULL;
   }
 
-  if (mathutils_array_parse_alloc(&tvec, size, value, "Vector.lerp(other), invalid 'other' arg") ==
-      -1) {
+  if (mathutils_array_parse_alloc(
+          &tvec, vec_num, value, "Vector.lerp(other), invalid 'other' arg") == -1) {
     return NULL;
   }
 
-  interp_vn_vn(tvec, self->vec, 1.0f - fac, size);
+  interp_vn_vn(tvec, self->vec, 1.0f - fac, vec_num);
 
-  return Vector_CreatePyObject_alloc(tvec, size, Py_TYPE(self));
+  return Vector_CreatePyObject_alloc(tvec, vec_num, Py_TYPE(self));
 }
 
 PyDoc_STRVAR(Vector_slerp_doc,
@@ -1185,7 +1187,7 @@ PyDoc_STRVAR(Vector_slerp_doc,
              "   :rtype: :class:`Vector`\n");
 static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
 {
-  const int size = self->size;
+  const int vec_num = self->vec_num;
   PyObject *value = NULL;
   float fac, cosom, w[2];
   float self_vec[3], other_vec[3], ret_vec[3];
@@ -1201,18 +1203,18 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
     return NULL;
   }
 
-  if (self->size > 3) {
+  if (self->vec_num > 3) {
     PyErr_SetString(PyExc_ValueError, "Vector must be 2D or 3D");
     return NULL;
   }
 
   if (mathutils_array_parse(
-          other_vec, size, size, value, "Vector.slerp(other), invalid 'other' arg") == -1) {
+          other_vec, vec_num, vec_num, value, "Vector.slerp(other), invalid 'other' arg") == -1) {
     return NULL;
   }
 
-  self_len_sq = normalize_vn_vn(self_vec, self->vec, size);
-  other_len_sq = normalize_vn(other_vec, size);
+  self_len_sq = normalize_vn_vn(self_vec, self->vec, vec_num);
+  other_len_sq = normalize_vn(other_vec, vec_num);
 
   /* use fallbacks for zero length vectors */
   if (UNLIKELY((self_len_sq < FLT_EPSILON) || (other_len_sq < FLT_EPSILON))) {
@@ -1229,7 +1231,7 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
   }
 
   /* We have sane state, execute slerp */
-  cosom = (float)dot_vn_vn(self_vec, other_vec, size);
+  cosom = (float)dot_vn_vn(self_vec, other_vec, vec_num);
 
   /* direct opposite, can't slerp */
   if (UNLIKELY(cosom < (-1.0f + FLT_EPSILON))) {
@@ -1247,11 +1249,11 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
 
   interp_dot_slerp(fac, cosom, w);
 
-  for (x = 0; x < size; x++) {
+  for (x = 0; x < vec_num; x++) {
     ret_vec[x] = (w[0] * self_vec[x]) + (w[1] * other_vec[x]);
   }
 
-  return Vector_CreatePyObject(ret_vec, size, Py_TYPE(self));
+  return Vector_CreatePyObject(ret_vec, vec_num, Py_TYPE(self));
 }
 
 PyDoc_STRVAR(
@@ -1270,7 +1272,7 @@ static PyObject *Vector_rotate(VectorObject *self, PyObject *value)
     return NULL;
   }
 
-  if (self->size == 2) {
+  if (self->vec_num == 2) {
     /* Special case for 2D Vector with 2x2 matrix, so we avoid resizing it to a 3x3. */
     float other_rmat[2][2];
     MatrixObject *pymat;
@@ -1311,7 +1313,7 @@ static PyObject *Vector_copy(VectorObject *self)
     return NULL;
   }
 
-  return Vector_CreatePyObject(self->vec, self->size, Py_TYPE(self));
+  return Vector_CreatePyObject(self->vec, self->vec_num, Py_TYPE(self));
 }
 static PyObject *Vector_deepcopy(VectorObject *self, PyObject *args)
 {
@@ -1350,7 +1352,7 @@ static PyObject *Vector_str(VectorObject *self)
 
   BLI_dynstr_append(ds, "<Vector (");
 
-  for (i = 0; i < self->size; i++) {
+  for (i = 0; i < self->vec_num; i++) {
     BLI_dynstr_appendf(ds, i ? ", %.4f" : "%.4f", self->vec[i]);
   }
 
@@ -1364,21 +1366,21 @@ static PyObject *Vector_str(VectorObject *self)
 /* sequence length len(vector) */
 static int Vector_len(VectorObject *self)
 {
-  return self->size;
+  return self->vec_num;
 }
 /* sequence accessor (get): vector[index] */
 static PyObject *vector_item_internal(VectorObject *self, int i, const bool is_attr)
 {
   if (i < 0) {
-    i = self->size - i;
+    i = self->vec_num - i;
   }
 
-  if (i < 0 || i >= self->size) {
+  if (i < 0 || i >= self->vec_num) {
     if (is_attr) {
       PyErr_Format(PyExc_AttributeError,
                    "Vector.%c: unavailable on %dd vector",
                    *(((const char *)"xyzw") + i),
-                   self->size);
+                   self->vec_num);
     }
     else {
       PyErr_SetString(PyExc_IndexError, "vector[index]: out of range");
@@ -1415,15 +1417,15 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value,
   }
 
   if (i < 0) {
-    i = self->size - i;
+    i = self->vec_num - i;
   }
 
-  if (i < 0 || i >= self->size) {
+  if (i < 0 || i >= self->vec_num) {
     if (is_attr) {
       PyErr_Format(PyExc_AttributeError,
                    "Vector.%c = x: unavailable on %dd vector",
                    *(((const char *)"xyzw") + i),
-                   self->size);
+                   self->vec_num);
     }
     else {
       PyErr_SetString(PyExc_IndexError,
@@ -1455,11 +1457,11 @@ static PyObject *Vector_slice(VectorObject *self, int begin, int end)
     return NULL;
   }
 
-  CLAMP(begin, 0, self->size);
+  CLAMP(begin, 0, self->vec_num);
   if (end < 0) {
-    end = self->size + end + 1;
+    end = self->vec_num + end + 1;
   }
-  CLAMP(end, 0, self->size);
+  CLAMP(end, 0, self->vec_num);
   begin = MIN2(begin, end);
 
   tuple = PyTuple_New(end - begin);
@@ -1472,19 +1474,19 @@ static PyObject *Vector_slice(VectorObject *self, int begin, int end)
 /* sequence slice (set): vector[a:b] = value */
 static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq)
 {
-  int size = 0;
+  int vec_num = 0;
   float *vec = NULL;
 
   if (BaseMath_ReadCallback_ForWrite(self) == -1) {
     return -1;
   }
 
-  CLAMP(begin, 0, self->size);
-  CLAMP(end, 0, self->size);
+  CLAMP(begin, 0, self->vec_num);
+  CLAMP(end, 0, self->vec_num);
   begin = MIN2(begin, end);
 
-  size = (end - begin);
-  if (mathutils_array_parse_alloc(&vec, size, seq, "vector[begin:end] = [...]") == -1) {
+  vec_num = (end - begin);
+  if (mathutils_array_parse_alloc(&vec, vec_num, seq, "vector[begin:end] = [...]") == -1) {
     return -1;
   }
 
@@ -1496,7 +1498,7 @@ static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *se
   }
 
   /* Parsed well - now set in vector. */
-  memcpy(self->vec + begin, vec, size * sizeof(float));
+  memcpy(self->vec + begin, vec, vec_num * sizeof(float));
 
   PyMem_Free(vec);
 
@@ -1530,14 +1532,14 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2)
   }
 
   /* VECTOR + VECTOR. */
-  if (vec1->size != vec2->size) {
+  if (vec1->vec_num != vec2->vec_num) {
     PyErr_SetString(PyExc_AttributeError,
                     "Vector addition: "
                     "vectors must have the same dimensions for this operation");
     return NULL;
   }
 
-  vec = PyMem_Malloc(vec1->size * sizeof(float));
+  vec = PyMem_Malloc(vec1->vec_num * sizeof(float));
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
                     "Vector(): "
@@ -1545,9 +1547,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  add_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
+  add_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->vec_num);
 
-  return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
+  return Vector_CreatePyObject_alloc(vec, vec1->vec_num, Py_TYPE(v1));
 }
 
 /* addition in-place: obj += obj */
@@ -1566,7 +1568,7 @@ static PyObject *Vector_iadd(PyObject *v1, PyObject *v2)
   vec1 = (VectorObject *)v1;
   vec2 = (VectorObject *)v2;
 
-  if (vec1->size != vec2->size) {
+  if (vec1->vec_num != vec2->vec_num) {
     PyErr_SetString(PyExc_AttributeError,
                     "Vector addition: "
                     "vectors must have the same dimensions for this operation");
@@ -1577,7 +1579,7 @@ static PyObject *Vector_iadd(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  add_vn_vn(vec1->vec, vec2->vec, vec1->size);
+  add_vn_vn(vec1->vec, vec2->vec, vec1->vec_num);
 
   (void)BaseMath_WriteCallback(vec1);
   Py_INCREF(v1);
@@ -1605,14 +1607,14 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  if (vec1->size != vec2->size) {
+  if (vec1->vec_num != vec2->vec_num) {
     PyErr_SetString(PyExc_AttributeError,
                     "Vector subtraction: "
                     "vectors must have the same dimensions for this operation");
     return NULL;
   }
 
-  vec = PyMem_Malloc(vec1->size * sizeof(float));
+  vec = PyMem_Malloc(vec1->vec_num * sizeof(float));
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
                     "Vector(): "
@@ -1620,9 +1622,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  sub_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
+  sub_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->vec_num);
 
-  return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
+  return Vector_CreatePyObject_alloc(vec, vec1->vec_num, Py_TYPE(v1));
 }
 
 /* subtraction in-place: obj -= obj */
@@ -1641,7 +1643,7 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
   vec1 = (VectorObject *)v1;
   vec2 = (VectorObject *)v2;
 
-  if (vec1->size != vec2->size) {
+  if (vec1->vec_num != vec2->vec_num) {
     PyErr_SetString(PyExc_AttributeError,
                     "Vector subtraction: "
                     "vectors must have the same dimensions for this operation");
@@ -1652,7 +1654,7 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  sub_vn_vn(vec1->vec, vec2->vec, vec1->size);
+  sub_vn_vn(vec1->vec, vec2->vec, vec1->vec_num);
 
   (void)BaseMath_WriteCallback(vec1);
   Py_INCREF(v1);
@@ -1667,8 +1669,8 @@ int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec,
   float vec_cpy[MAX_DIMENSIONS];
   int row, col, z = 0;
 
-  if (mat->num_col != vec->size) {
-    if (mat->num_col == 4 && vec->size == 3) {
+  if (mat->col_num != vec->vec_num) {
+    if (mat->col_num == 4 && vec->vec_num == 3) {
       vec_cpy[3] = 1.0f;
     }
     else {
@@ -1680,13 +1682,13 @@ int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec,
     }
   }
 
-  memcpy(vec_cpy, vec->vec, vec->size * sizeof(float));
+  memcpy(vec_cpy, vec->vec, vec->vec_num * sizeof(float));
 
   r_vec[3] = 1.0f;
 
-  for (row = 0; row < mat->num_row; row++) {
+  for (row = 0; row < mat->row_num; row++) {
     double dot = 0.0f;
-    for (col = 0; col < mat->num_col; col++) {
+    for (col = 0; col < mat->col_num; col++) {
       dot += (double)(MATRIX_ITEM(mat, row, col) * vec_cpy[col]);
     }
     r_vec[z++] = (float)dot;
@@ -1697,7 +1699,7 @@ int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec,
 
 static PyObject *vector_mul_float(VectorObject *vec, const float scalar)
 {
-  float *tvec = PyMem_Malloc(vec->size * sizeof(float));
+  float *tvec = PyMem_Malloc(vec->vec_num * sizeof(float));
   if (tvec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
                     "vec * float: "
@@ -1705,13 +1707,13 @@ static PyObject *vector_mul_float(VectorObject *vec, const float scalar)
     return NULL;
   }
 
-  mul_vn_vn_fl(tvec, vec->vec, vec->size, scalar);
-  return Vector_CreatePyObject_alloc(tvec, vec->size, Py_TYPE(vec));
+  mul_vn_vn_fl(tvec, vec->vec, vec->vec_num, scalar);
+  return Vector_CreatePyObject_alloc(tvec, vec->vec_num, Py_TYPE(vec));
 }
 
 static PyObject *vector_mul_vec(VectorObject *vec1, VectorObject *vec2)
 {
-  float *tvec = PyMem_Malloc(vec1->size * sizeof(float));
+  float *tvec = PyMem_Malloc(vec1->vec_num * sizeof(float));
   if (tvec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
                     "vec * vec: "
@@ -1719,8 +1721,8 @@ static PyObject *vector_mul_vec(VectorObject *vec1, VectorObject *vec2)
     return NULL;
   }
 
-  mul_vn_vnvn(tvec, vec1->vec, vec2->vec, vec1->size);
-  return Vector_CreatePyObject_alloc(tvec, vec1->size, Py_TYPE(vec1));
+  mul_vn_vnvn(tvec, vec1->vec, vec2->vec, vec1->vec_num);
+  return Vector_CreatePyObject_alloc(tvec, vec1->vec_num, Py_TYPE(vec1));
 }
 
 static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
@@ -1745,7 +1747,7 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
 
   /* make sure v1 is always the vector */
   if (vec1 && vec2) {
-    if (vec1->size != vec2->size) {
+    if (vec1->vec_num != vec2->vec_num) {
       PyErr_SetString(PyExc_ValueError,
                       "Vector multiplication: "
                       "vectors must have the same dimensions for this operation");
@@ -1800,7 +1802,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
   /* Intentionally don't support (Quaternion, Matrix) here, uses reverse order instead. */
 
   if (vec1 && vec2) {
-    if (vec1->size != vec2->size) {
+    if (vec1->vec_num != vec2->vec_num) {
       PyErr_SetString(PyExc_ValueError,
                       "Vector multiplication: "
                       "vectors must have the same dimensions for this operation");
@@ -1808,11 +1810,11 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
     }
 
     /* Element-wise product in-place. */
-    mul_vn_vn(vec1->vec, vec2->vec, vec1->size);
+    mul_vn_vn(vec1->vec, vec2->vec, vec1->vec_num);
   }
   else if (vec1 && (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) ==
                     0)) { /* VEC *= FLOAT */
-    mul_vn_fl(vec1->vec, vec1->size, scalar);
+    mul_vn_fl(vec1->vec, vec1->vec_num, scalar);
   }
   else {
     PyErr_Format(PyExc_TypeError,
@@ -1831,7 +1833,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
 static PyObject *Vector_matmul(PyObject *v1, PyObject *v2)
 {
   VectorObject *vec1 = NULL, *vec2 = NULL;
-  int vec_size;
+  int vec_num;
 
   if (VectorObject_Check(v1)) {
     vec1 = (VectorObject *)v1;
@@ -1850,7 +1852,7 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2)
 
   /* make sure v1 is always the vector */
   if (vec1 && vec2) {
-    if (vec1->size != vec2->size) {
+    if (vec1->vec_num != vec2->vec_num) {
       PyErr_SetString(PyExc_ValueError,
                       "Vector multiplication: "
                       "vectors must have the same dimensions for this operation");
@@ -1858,7 +1860,7 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2)
     }
 
     /* Dot product. */
-    return PyFloat_FromDouble(dot_vn_vn(vec1->vec, vec2->vec, vec1->size));
+    return PyFloat_FromDouble(dot_vn_vn(vec1->vec, vec2->vec, vec1->vec_num));
   }
   if (vec1) {
     if (MatrixObject_Check(v2)) {
@@ -1872,14 +1874,14 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2)
         return NULL;
       }
 
-      if (((MatrixObject *)v2)->num_row == 4 && vec1->size == 3) {
-        vec_size = 3;
+      if (((MatrixObject *)v2)->row_num == 4 && vec1->vec_num == 3) {
+        vec_num = 3;
       }
       else {
-        vec_size = ((MatrixObject *)v2)->num_col;
+        vec_num = ((MatrixObject *)v2)->col_num;
       }
 
-      return Vector_CreatePyObject(tvec, vec_size, Py_TYPE(vec1));
+      return Vector_CreatePyObject(tvec, vec_num, Py_TYPE(vec1));
     }
   }
 
@@ -1934,7 +1936,7 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  vec = PyMem_Malloc(vec1->size * sizeof(float));
+  vec = PyMem_Malloc(vec1->vec_num * sizeof(float));
 
   if (vec == NULL) {
     PyErr_SetString(PyExc_MemoryError,
@@ -1943,9 +1945,9 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  mul_vn_vn_fl(vec, vec1->vec, vec1->size, 1.0f / scalar);
+  mul_vn_vn_fl(vec, vec1->vec, vec1->vec_num, 1.0f / scalar);
 
-  return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
+  return Vector_CreatePyObject_alloc(vec, vec1->vec_num, Py_TYPE(v1));
 }
 
 /* divide in-place: obj /= obj */
@@ -1973,7 +1975,7 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
     return NULL;
   }
 
-  mul_vn_fl(vec1->vec, vec1->size, 1.0f / scalar);
+  mul_vn_fl(vec1->vec, vec1->vec_num, 1.0f / scalar);
 
   (void)BaseMath_WriteCallback(vec1);
 
@@ -1991,9 +1993,9 @@ static PyObject *Vector_neg(VectorObject *self)
     return NULL;
   }
 
-  tvec = PyMem_Malloc(self->size * sizeof(float));
-  negate_vn_vn(tvec, self->vec, self->size);
-  return Vector_CreatePyObject_alloc(tvec, self->size, Py_TYPE(self));
+  tvec = PyMem_Malloc(self->vec_num * sizeof(float));
+  negate_vn_vn(tvec, self->vec, self->vec_num);
+  return Vector_CreatePyObject_alloc(tvec, self->vec_num, Py_TYPE(self));
 }
 
 /*------------------------tp_richcmpr
@@ -2019,7 +2021,7 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
     return NULL;
   }
 
-  if (vecA->size != vecB->size) {
+  if (vecA->vec_num != vecB->vec_num) {
     if (comparison_type == Py_NE) {
       Py_RETURN_TRUE;
     }
@@ -2029,15 +2031,15 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
 
   switch (comparison_type) {
     case Py_LT:
-      lenA = len_squared_vn(vecA->vec, vecA->size);
-      lenB = len_squared_vn(vecB->vec, vecB->size);
+      lenA = len_squared_vn(vecA->vec, vecA->vec_num);
+      lenB = len_squared_vn(vecB->vec, vecB->vec_num);
       if (lenA < lenB) {
         result = 1;
       }
       break;
     case Py_LE:
-      lenA = len_squared_vn(vecA->vec, vecA->size);
-      lenB = len_squared_vn(vecB->vec, vecB->size);
+      lenA = len_squared_vn(vecA->vec, vecA->vec_num);
+      lenB = len_squared_vn(vecB->vec, vecB->vec_num);
       if (lenA < lenB) {
         result = 1;
       }
@@ -2046,21 +2048,21 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
       }
       break;
     case Py_EQ:
-      result = EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
+      result = EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->vec_num, 1);
       break;
     case Py_NE:
-      result = !EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
+      result = !EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->vec_num, 1);
       break;
     case Py_GT:
-      lenA = len_squared_vn(vecA->vec, vecA->size);
-      lenB = len_squared_vn(vecB->vec, vecB->size);
+      lenA = len_squared_vn(vecA->vec, vecA->vec_num);
+      lenB = len_squared_vn(vecB->vec, vecB->vec_num);
       if (lenA > lenB) {
         result = 1;
       }
       break;
     case Py_GE:
-      lenA = len_squared_vn(vecA->vec, vecA->size);
-      lenB = len_squared_vn(vecB->vec, vecB->size);
+      lenA = len_squared_vn(vecA->vec, vecA->vec_num);
+      lenB = len_squared_vn(vecB->vec, vecB->vec_num);
       if (lenA > lenB) {
         result = 1;
       }
@@ -2089,7 +2091,7 @@ static Py_hash_t Vector_hash(VectorObject *self)
     return -1;
   }
 
-  return mathutils_array_hash(self->vec, self->size);
+  return mathutils_array_hash(self->vec, self->vec_num);
 }
 
 /*-----------------PROTCOL DECLARATIONS--------------------------*/
@@ -2115,14 +2117,14 @@ static PyObject *Vector_subscript(VectorObject *self, PyObject *item)
       return NULL;
     }
     if (i < 0) {
-      i += self->size;
+      i += self->vec_num;
     }
     return Vector_item(self, i);
   }
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
-    if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) {
+    if (PySlice_GetIndicesEx(item, self->vec_num, &start, &stop, &step, &slicelength) < 0) {
       return NULL;
     }
 
@@ -2150,14 +2152,14 @@ static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *va
       return -1;
     }
     if (i < 0) {
-      i += self->size;
+      i += self->vec_num;
     }
     return Vector_ass_item(self, i, value);
   }
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
-    if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) {
+    if (PySlice_GetIndicesEx(item, self->vec_num, &start, &stop, &step, &slicelength) < 0) {
       return -1;
     }
 
@@ -2247,7 +2249,7 @@ static PyObject *Vector_length_get(VectorObject *self, void *UNUSED(closure))
     return NULL;
   }
 
-  return PyFloat_FromDouble(sqrt(dot_vn_vn(self->vec, self->vec, self->size)));
+  return PyFloat_FromDouble(sqrt(dot_vn_vn(self->vec, self->vec, self->vec_num)));
 }
 
 static int Vector_length_set(VectorObject *self, PyObject *value)
@@ -2268,11 +2270,11 @@ static int Vector_length_set(VectorObject *self, PyObject *value)
     return -1;
   }
   if (param == 0.0) {
-    copy_vn_fl(self->vec, self->size, 0.0f);
+    copy_vn_fl(self->vec, self->vec_num, 0.0f);
     return 0;
   }
 
-  dot = dot_vn_vn(self->vec, self->vec, self->size);
+  dot = dot_vn_vn(self->vec, self->vec, self->vec_num);
 
   if (!dot) {
     /* can't sqrt zero */
@@ -2287,7 +2289,7 @@ static int Vector_length_set(VectorObject *self, PyObject *value)
 
   dot = dot / param;
 
-  mul_vn_fl(self->vec, self->size, 1.0 / dot);
+  mul_vn_fl(self->vec, self->vec_num, 1.0 / dot);
 
   (void)BaseMath_WriteCallback(self); /* checked already */
 
@@ -2302,7 +2304,7 @@ static PyObject *Vector_length_squared_get(VectorObject *self, void *UNUSED(clos
     return NULL;
   }
 
-  return PyFloat_FromDouble(dot_vn_vn(self->vec, self->vec, self->size));
+  return PyFloat_FromDouble(dot_vn_vn(self->vec, self->vec, self->vec_num));
 }
 
 /**
@@ -2382,7 +2384,7 @@ static PyObject *Vector_swizzle_get(VectorObject *self, void *closure)
   swizzleClosure = POINTER_AS_INT(closure);
   while (swizzleClosure & SWIZZLE_VALID_AXIS) {
     axis_from = swizzleClosure & SWIZZLE_AXIS;
-    if (axis_from >= self->size) {
+    if (axis_from >= self->vec_num) {
       PyErr_SetString(PyExc_AttributeError,
                       "Vector swizzle: "
                       "specified axis not present");
@@ -2432,7 +2434,7 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
 
   while (swizzleClosure & SWIZZLE_VALID_AXIS) {
     axis_to = swizzleClosure & SWIZZLE_AXIS;
-    if (axis_to >= self->size) {
+    if (axis_to >= self->vec_num) {
       PyErr_SetString(PyExc_AttributeError,
                       "Vector swizzle: "
                       "specified axis not present");
@@ -2468,8 +2470,8 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
 
   /* We must first copy current vec into tvec, else some org values may be lost.
    * See T31760.
-   * Assuming self->size can't be higher than MAX_DIMENSIONS! */
-  memcpy(tvec, self->vec, self->size * sizeof(float));
+   * Assuming self->vec_num can't be higher than MAX_DIMENSIONS! */
+  memcpy(tvec, self->vec, self->vec_num * sizeof(float));
 
   while (swizzleClosure & SWIZZLE_VALID_AXIS) {
     axis_to = swizzleClosure & SWIZZLE_AXIS;
@@ -2480,7 +2482,7 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
 
   /* We must copy back the whole tvec into vec, else some changes may be lost (e.g. xz...).
    * See T31760. */
-  memcpy(self->vec, tvec, self->size * sizeof(float));
+  memcpy(self->vec, tvec, self->vec_num * sizeof(float));
   /* continue with BaseMathObject_WriteCallback at the end */
 
   if (BaseMath_WriteCallback(self) == -1) {
@@ -2898,10 +2900,10 @@ static int row_vector_multiplication(float r_vec[MAX_DIMENSIONS],
                                      MatrixObject *mat)
 {
   float vec_cpy[MAX_DIMENSIONS];
-  int row, col, z = 0, vec_size = vec->size;
+  int row, col, z = 0, vec_num = vec->vec_num;
 
-  if (mat->num_row != vec_size) {
-    if (mat->num_row == 4 && vec_size == 3) {
+  if (mat->row_num != vec_num) {
+    if (mat->row_num == 4 && vec_num == 3) {
       vec_cpy[3] = 1.0f;
     }
     else {
@@ -2916,13 +2918,13 @@ static int row_vector_multiplication(float r_vec[MAX_DIMENSIONS],
     return -1;
   }
 
-  memcpy(vec_cpy, vec->vec, vec_size * sizeof(float));
+  memcpy(vec_cpy, vec->vec, vec_num * sizeof(float));
 
   r_vec[3] = 1.0f;
   /* Multiplication. */
-  for (col = 0; col < mat->num_col; col++) {
+  for (col = 0; col < mat->col_num; col++) {
     double dot = 0.0;
-    for (row = 0; row < mat->num_row; row++) {
+    for (row = 0; row < mat->row_num; row++) {
       dot += (double)(MATRIX_ITEM(mat, row, col) * vec_cpy[row]);
     }
     r_vec[z++] = (float)dot;
@@ -2941,7 +2943,7 @@ static PyObject *Vector_negate(VectorObject *self)
     return NULL;
   }
 
-  negate_vn(self->vec, self->size);
+  negate_vn(self->vec, self->vec_num);
 
   (void)BaseMath_WriteCallback(self); /* already checked for error */
   Py_RETURN_NONE;
@@ -3096,17 +3098,17 @@ PyTypeObject vector_Type = {
     NULL,
 };
 
-PyObject *Vector_CreatePyObject(const float *vec, const int size, PyTypeObject *base_type)
+PyObject *Vector_CreatePyObject(const float *vec, const int vec_num, PyTypeObject *base_type)
 {
   VectorObject *self;
   float *vec_alloc;
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
     return NULL;
   }
 
-  vec_alloc = PyMem_Malloc(size * sizeof(float));
+  vec_alloc = PyMem_Malloc(vec_num * sizeof(float));
   if (UNLIKELY(vec_alloc == NULL)) {
     PyErr_SetString(PyExc_MemoryError,
                     "Vector(): "
@@ -3117,18 +3119,18 @@ PyObject *Vector_CreatePyObject(const float *vec, const int size, PyTypeObject *
   self = BASE_MATH_NEW(VectorObject, vector_Type, base_type);
   if (self) {
     self->vec = vec_alloc;
-    self->size = size;
+    self->vec_num = vec_num;
 
     /* init callbacks as NULL */
     self->cb_user = NULL;
     self->cb_type = self->cb_subtype = 0;
 
     if (vec) {
-      memcpy(self->vec, vec, size * sizeof(float));
+      memcpy(self->vec, vec, vec_num * sizeof(float));
     }
     else { /* new empty */
-      copy_vn_fl(self->vec, size, 0.0f);
-      if (size == 4) { /* do the homogeneous thing */
+      copy_vn_fl(self->vec, vec_num, 0.0f);
+      if (vec_num == 4) { /* do the homogeneous thing */
         self->vec[3] = 1.0f;
       }
     }
@@ -3141,18 +3143,18 @@ PyObject *Vector_CreatePyObject(const float *vec, const int size, PyTypeObject *
   return (PyObject *)self;
 }
 
-PyObject *Vector_CreatePyObject_wrap(float *vec, const int size, PyTypeObject *base_type)
+PyObject *Vector_CreatePyObject_wrap(float *vec, const int vec_num, PyTypeObject *base_type)
 {
   VectorObject *self;
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
     return NULL;
   }
 
   self = BASE_MATH_NEW(VectorObject, vector_Type, base_type);
   if (self) {
-    self->size = size;
+    self->vec_num = vec_num;
 
     /* init callbacks as NULL */
     self->cb_user = NULL;
@@ -3164,9 +3166,9 @@ PyObject *Vector_CreatePyObject_wrap(float *vec, const int size, PyTypeObject *b
   return (PyObject *)self;
 }
 
-PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int size, uchar cb_type, uchar cb_subtype)
+PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int vec_num, uchar cb_type, uchar cb_subtype)
 {
-  VectorObject *self = (VectorObject *)Vector_CreatePyObject(NULL, size, NULL);
+  VectorObject *self = (VectorObject *)Vector_CreatePyObject(NULL, vec_num, NULL);
   if (self) {
     Py_INCREF(cb_user);
     self->cb_user = cb_user;
@@ -3178,10 +3180,10 @@ PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int size, uchar cb_type, u
   return (PyObject *)self;
 }
 
-PyObject *Vector_CreatePyObject_alloc(float *vec, const int size, PyTypeObject *base_type)
+PyObject *Vector_CreatePyObject_alloc(float *vec, const int vec_num, PyTypeObject *base_type)
 {
   VectorObject *self;
-  self = (VectorObject *)Vector_CreatePyObject_wrap(vec, size, base_type);
+  self = (VectorObject *)Vector_CreatePyObject_wrap(vec, vec_num, base_type);
   if (self) {
     self->flag &= ~BASE_MATH_FLAG_IS_WRAP;
   }
diff --git a/source/blender/python/mathutils/mathutils_Vector.h b/source/blender/python/mathutils/mathutils_Vector.h
index 422050c8742..3bc4e9d6b6f 100644
--- a/source/blender/python/mathutils/mathutils_Vector.h
+++ b/source/blender/python/mathutils/mathutils_Vector.h
@@ -14,12 +14,13 @@ extern PyTypeObject vector_Type;
 typedef struct {
   BASE_MATH_MEMBERS(vec);
 
-  int size; /* vec size 2 or more */
+  /** Number of items in this vector (2 or more). */
+  int vec_num;
 } VectorObject;
 
 /*prototypes*/
 PyObject *Vector_CreatePyObject(const float *vec,
-                                int size,
+                                int vec_num,
                                 PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT;
 /**
  * Create a vector that wraps existing memory.
@@ -27,7 +28,7 @@ PyObject *Vector_CreatePyObject(const float *vec,
  * \param vec: Use this vector in-place.
  */
 PyObject *Vector_CreatePyObject_wrap(float *vec,
-                                     int size,
+                                     int vec_num,
                                      PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL(1);
 /**
@@ -35,13 +36,13 @@ PyObject *Vector_CreatePyObject_wrap(float *vec,
  * see: #Mathutils_RegisterCallback
  */
 PyObject *Vector_CreatePyObject_cb(PyObject *user,
-                                   int size,
+                                   int vec_num,
                                    unsigned char cb_type,
                                    unsigned char subtype) ATTR_WARN_UNUSED_RESULT;
 /**
  * \param vec: Initialized vector value to use in-place, allocated with #PyMem_Malloc
  */
 PyObject *Vector_CreatePyObject_alloc(float *vec,
-                                      int size,
+                                      int vec_num,
                                       PyTypeObject *base_type) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL(1);
diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c
index 84ba2ce4031..1e492574903 100644
--- a/source/blender/python/mathutils/mathutils_geometry.c
+++ b/source/blender/python/mathutils/mathutils_geometry.c
@@ -158,24 +158,30 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
   PyObject *tuple;
   PyObject *py_lines[4];
   float lines[4][3], i1[3], i2[3];
-  int len;
+  int ix_vec_num;
   int result;
 
   if (!PyArg_ParseTuple(args, "OOOO:intersect_line_line", UNPACK4_EX(&, py_lines, ))) {
     return NULL;
   }
 
-  if ((((len = mathutils_array_parse(
+  if ((((ix_vec_num = mathutils_array_parse(
              lines[0], 2, 3 | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_lines[0], error_prefix)) != -1) &&
-       (mathutils_array_parse(
-            lines[1], len, len | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_lines[1], error_prefix) !=
-        -1) &&
-       (mathutils_array_parse(
-            lines[2], len, len | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_lines[2], error_prefix) !=
-        -1) &&
-       (mathutils_array_parse(
-            lines[3], len, len | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_lines[3], error_prefix) !=
-        -1)) == 0) {
+       (mathutils_array_parse(lines[1],
+                              ix_vec_num,
+                              ix_vec_num | MU_ARRAY_SPILL | MU_ARRAY_ZERO,
+                              py_lines[1],
+                              error_prefix) != -1) &&
+       (mathutils_array_parse(lines[2],
+                              ix_vec_num,
+                              ix_vec_num | MU_ARRAY_SPILL | MU_ARRAY_ZERO,
+                              py_lines[2],
+                              error_prefix) != -1) &&
+       (mathutils_array_parse(lines[3],
+                              ix_vec_num,
+                              ix_vec_num | MU_ARRAY_SPILL | MU_ARRAY_ZERO,
+                              py_lines[3],
+                              error_prefix) != -1)) == 0) {
     return NULL;
   }
 
@@ -192,8 +198,9 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
   }
 
   tuple = PyTuple_New(2);
-  PyTuple_SET_ITEMS(
-      tuple, Vector_CreatePyObject(i1, len, NULL), Vector_CreatePyObject(i2, len, NULL));
+  PyTuple_SET_ITEMS(tuple,
+                    Vector_CreatePyObject(i1, ix_vec_num, NULL),
+                    Vector_CreatePyObject(i2, ix_vec_num, NULL));
   return tuple;
 }
 
@@ -764,14 +771,14 @@ static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObjec
   float pt[3], pt_out[3], line_a[3], line_b[3];
   float lambda;
   PyObject *ret;
-  int size = 2;
+  int pt_num = 2;
 
   if (!PyArg_ParseTuple(args, "OOO:intersect_point_line", &py_pt, &py_line_a, &py_line_b)) {
     return NULL;
   }
 
   /* accept 2d verts */
-  if ((((size = mathutils_array_parse(
+  if ((((pt_num = mathutils_array_parse(
              pt, 2, 3 | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_pt, error_prefix)) != -1) &&
        (mathutils_array_parse(
             line_a, 2, 3 | MU_ARRAY_SPILL | MU_ARRAY_ZERO, py_line_a, error_prefix) != -1) &&
@@ -784,7 +791,7 @@ static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObjec
   lambda = closest_to_line_v3(pt_out, pt, line_a, line_b);
 
   ret = PyTuple_New(2);
-  PyTuple_SET_ITEMS(ret, Vector_CreatePyObject(pt_out, size, NULL), PyFloat_FromDouble(lambda));
+  PyTuple_SET_ITEMS(ret, Vector_CreatePyObject(pt_out, pt_num, NULL), PyFloat_FromDouble(lambda));
   return ret;
 }
 
diff --git a/source/blender/python/mathutils/mathutils_noise.c b/source/blender/python/mathutils/mathutils_noise.c
index 0853c5dd3ea..e1282e90c48 100644
--- a/source/blender/python/mathutils/mathutils_noise.c
+++ b/source/blender/python/mathutils/mathutils_noise.c
@@ -305,23 +305,24 @@ static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *ar
   static const char *kwlist[] = {"size", NULL};
   float vec[4] = {0.0f, 0.0f, 0.0f, 0.0f};
   float norm = 2.0f;
-  int size = 3;
+  int vec_num = 3;
 
-  if (!PyArg_ParseTupleAndKeywords(args, kw, "|$i:random_unit_vector", (char **)kwlist, &size)) {
+  if (!PyArg_ParseTupleAndKeywords(
+          args, kw, "|$i:random_unit_vector", (char **)kwlist, &vec_num)) {
     return NULL;
   }
 
-  if (size > 4 || size < 2) {
+  if (vec_num > 4 || vec_num < 2) {
     PyErr_SetString(PyExc_ValueError, "Vector(): invalid size");
     return NULL;
   }
 
   while (norm == 0.0f || norm > 1.0f) {
-    rand_vn(vec, size);
-    norm = normalize_vn(vec, size);
+    rand_vn(vec, vec_num);
+    norm = normalize_vn(vec, vec_num);
   }
 
-  return Vector_CreatePyObject(vec, size, NULL);
+  return Vector_CreatePyObject(vec, vec_num, NULL);
 }
 
 PyDoc_STRVAR(M_Noise_random_vector_doc,
@@ -337,22 +338,22 @@ static PyObject *M_Noise_random_vector(PyObject *UNUSED(self), PyObject *args, P
 {
   static const char *kwlist[] = {"size", NULL};
   float *vec = NULL;
-  int size = 3;
+  int vec_num = 3;
 
-  if (!PyArg_ParseTupleAndKeywords(args, kw, "|$i:random_vector", (char **)kwlist, &size)) {
+  if (!PyArg_ParseTupleAndKeywords(args, kw, "|$i:random_vector", (char **)kwlist, &vec_num)) {
     return NULL;
   }
 
-  if (size < 2) {
+  if (vec_num < 2) {
     PyErr_SetString(PyExc_ValueError, "Vector(): invalid size");
     return NULL;
   }
 
-  vec = PyMem_New(float, size);
+  vec = PyMem_New(float, vec_num);
 
-  rand_vn(vec, size);
+  rand_vn(vec, vec_num);
 
-  return Vector_CreatePyObject_alloc(vec, size, NULL);
+  return Vector_CreatePyObject_alloc(vec, vec_num, NULL);
 }
 
 PyDoc_STRVAR(M_Noise_seed_set_doc,