Cleanup: use "num" as a suffix in: source/blender/modifiers

Also rename DNA struct members.

1 files changed, 81 insertions, 81 deletions

diff --git a/source/blender/modifiers/intern/MOD_weighted_normal.c b/source/blender/modifiers/intern/MOD_weighted_normal.c
index 873372a35b8..c79dbdb0b1a 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.c
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.c
@@ -58,7 +58,7 @@ static int modepair_cmp_by_val_inverse(const void *p1, const void *p2)
 typedef struct WeightedNormalDataAggregateItem {
   float normal[3];
 
-  int num_loops;     /* Count number of loops using this item so far. */
+  int loops_num;     /* Count number of loops using this item so far. */
   float curr_val;    /* Current max val for this item. */
   int curr_strength; /* Current max strength encountered for this item. */
 } WeightedNormalDataAggregateItem;
@@ -66,10 +66,10 @@ typedef struct WeightedNormalDataAggregateItem {
 #define NUM_CACHED_INVERSE_POWERS_OF_WEIGHT 128
 
 typedef struct WeightedNormalData {
-  const int numVerts;
-  const int numEdges;
-  const int numLoops;
-  const int numPolys;
+  const int verts_num;
+  const int edges_num;
+  const int loops_num;
+  const int polys_num;
 
   MVert *mvert;
   const float (*vert_normals)[3];
@@ -116,7 +116,7 @@ static bool check_item_poly_strength(WeightedNormalData *wn_data,
   if (mp_strength > item_data->curr_strength) {
     item_data->curr_strength = mp_strength;
     item_data->curr_val = 0.0f;
-    item_data->num_loops = 0;
+    item_data->loops_num = 0;
     zero_v3(item_data->normal);
   }
 
@@ -160,20 +160,20 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
   }
   if (!compare_ff(item_data->curr_val, curr_val, wnmd->thresh)) {
     /* item's curr_val and present value differ more than threshold, update. */
-    item_data->num_loops++;
+    item_data->loops_num++;
     item_data->curr_val = curr_val;
   }
 
   /* Exponentially divided weight for each normal
    * (since a few values will be used by most cases, we cache those). */
-  const int num_loops = item_data->num_loops;
-  if (num_loops < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT &&
-      cached_inverse_powers_of_weight[num_loops] == 0.0f) {
-    cached_inverse_powers_of_weight[num_loops] = 1.0f / powf(weight, num_loops);
+  const int loops_num = item_data->loops_num;
+  if (loops_num < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT &&
+      cached_inverse_powers_of_weight[loops_num] == 0.0f) {
+    cached_inverse_powers_of_weight[loops_num] = 1.0f / powf(weight, loops_num);
   }
-  const float inverted_n_weight = num_loops < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT ?
-                                      cached_inverse_powers_of_weight[num_loops] :
-                                      1.0f / powf(weight, num_loops);
+  const float inverted_n_weight = loops_num < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT ?
+                                      cached_inverse_powers_of_weight[loops_num] :
+                                      1.0f / powf(weight, loops_num);
 
   madd_v3_v3fl(item_data->normal, polynors[mp_index], curr_val * inverted_n_weight);
 }
@@ -181,10 +181,10 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
 static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                         WeightedNormalData *wn_data)
 {
-  const int numVerts = wn_data->numVerts;
-  const int numEdges = wn_data->numEdges;
-  const int numLoops = wn_data->numLoops;
-  const int numPolys = wn_data->numPolys;
+  const int verts_num = wn_data->verts_num;
+  const int edges_num = wn_data->edges_num;
+  const int loops_num = wn_data->loops_num;
+  const int polys_num = wn_data->polys_num;
 
   MVert *mvert = wn_data->mvert;
   MEdge *medge = wn_data->medge;
@@ -214,39 +214,39 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
   float(*loop_normals)[3] = NULL;
 
   WeightedNormalDataAggregateItem *items_data = NULL;
-  int num_items = 0;
+  int items_num = 0;
   if (keep_sharp) {
-    BLI_bitmap *done_loops = BLI_BITMAP_NEW(numLoops, __func__);
+    BLI_bitmap *done_loops = BLI_BITMAP_NEW(loops_num, __func__);
 
     /* This will give us loop normal spaces,
      * we do not actually care about computed loop_normals for now... */
-    loop_normals = MEM_calloc_arrayN((size_t)numLoops, sizeof(*loop_normals), __func__);
+    loop_normals = MEM_calloc_arrayN((size_t)loops_num, sizeof(*loop_normals), __func__);
     BKE_mesh_normals_loop_split(mvert,
                                 wn_data->vert_normals,
-                                numVerts,
+                                verts_num,
                                 medge,
-                                numEdges,
+                                edges_num,
                                 mloop,
                                 loop_normals,
-                                numLoops,
+                                loops_num,
                                 mpoly,
                                 polynors,
-                                numPolys,
+                                polys_num,
                                 true,
                                 split_angle,
                                 &lnors_spacearr,
                                 has_clnors ? clnors : NULL,
                                 loop_to_poly);
 
-    num_items = lnors_spacearr.num_spaces;
-    items_data = MEM_calloc_arrayN((size_t)num_items, sizeof(*items_data), __func__);
+    items_num = lnors_spacearr.spaces_num;
+    items_data = MEM_calloc_arrayN((size_t)items_num, sizeof(*items_data), __func__);
 
     /* In this first loop, we assign each WeightedNormalDataAggregateItem
      * to its smooth fan of loops (aka lnor space). */
     MPoly *mp;
     int mp_index;
     int item_index;
-    for (mp = mpoly, mp_index = 0, item_index = 0; mp_index < numPolys; mp++, mp_index++) {
+    for (mp = mpoly, mp_index = 0, item_index = 0; mp_index < polys_num; mp++, mp_index++) {
       int ml_index = mp->loopstart;
       const int ml_end_index = ml_index + mp->totloop;
 
@@ -255,7 +255,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
           /* Smooth fan of this loop has already been processed, skip it. */
           continue;
         }
-        BLI_assert(item_index < num_items);
+        BLI_assert(item_index < items_num);
 
         WeightedNormalDataAggregateItem *itdt = &items_data[item_index];
         itdt->curr_strength = FACE_STRENGTH_WEAK;
@@ -280,10 +280,10 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
     MEM_freeN(done_loops);
   }
   else {
-    num_items = numVerts;
-    items_data = MEM_calloc_arrayN((size_t)num_items, sizeof(*items_data), __func__);
+    items_num = verts_num;
+    items_data = MEM_calloc_arrayN((size_t)items_num, sizeof(*items_data), __func__);
     if (use_face_influence) {
-      for (int item_index = 0; item_index < num_items; item_index++) {
+      for (int item_index = 0; item_index < items_num; item_index++) {
         items_data[item_index].curr_strength = FACE_STRENGTH_WEAK;
       }
     }
@@ -292,7 +292,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
 
   switch (mode) {
     case MOD_WEIGHTEDNORMAL_MODE_FACE:
-      for (int i = 0; i < numPolys; i++) {
+      for (int i = 0; i < polys_num; i++) {
         const int mp_index = mode_pair[i].index;
         const float mp_val = mode_pair[i].val;
 
@@ -312,7 +312,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
     case MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE:
       BLI_assert(loop_to_poly != NULL);
 
-      for (int i = 0; i < numLoops; i++) {
+      for (int i = 0; i < loops_num; i++) {
         const int ml_index = mode_pair[i].index;
         const float ml_val = mode_pair[i].val;
 
@@ -330,7 +330,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
   }
 
   /* Validate computed weighted normals. */
-  for (int item_index = 0; item_index < num_items; item_index++) {
+  for (int item_index = 0; item_index < items_num; item_index++) {
     if (normalize_v3(items_data[item_index].normal) < CLNORS_VALID_VEC_LEN) {
       zero_v3(items_data[item_index].normal);
     }
@@ -341,7 +341,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
      * Note that loop_normals is already populated with clnors
      * (before this modifier is applied, at start of this function),
      * so no need to recompute them here. */
-    for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+    for (int ml_index = 0; ml_index < loops_num; ml_index++) {
       WeightedNormalDataAggregateItem *item_data = lnors_spacearr.lspacearr[ml_index]->user_data;
       if (!is_zero_v3(item_data->normal)) {
         copy_v3_v3(loop_normals[ml_index], item_data->normal);
@@ -350,15 +350,15 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
 
     BKE_mesh_normals_loop_custom_set(mvert,
                                      wn_data->vert_normals,
-                                     numVerts,
+                                     verts_num,
                                      medge,
-                                     numEdges,
+                                     edges_num,
                                      mloop,
                                      loop_normals,
-                                     numLoops,
+                                     loops_num,
                                      mpoly,
                                      polynors,
-                                     numPolys,
+                                     polys_num,
                                      clnors);
   }
   else {
@@ -372,9 +372,9 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
        * But think we can live with it for now,
        * and it makes code simpler & cleaner. */
       float(*vert_normals)[3] = MEM_calloc_arrayN(
-          (size_t)numVerts, sizeof(*loop_normals), __func__);
+          (size_t)verts_num, sizeof(*loop_normals), __func__);
 
-      for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+      for (int ml_index = 0; ml_index < loops_num; ml_index++) {
         const int mv_index = mloop[ml_index].v;
         copy_v3_v3(vert_normals[mv_index], items_data[mv_index].normal);
       }
@@ -382,39 +382,39 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
       BKE_mesh_normals_loop_custom_from_vertices_set(mvert,
                                                      wn_data->vert_normals,
                                                      vert_normals,
-                                                     numVerts,
+                                                     verts_num,
                                                      medge,
-                                                     numEdges,
+                                                     edges_num,
                                                      mloop,
-                                                     numLoops,
+                                                     loops_num,
                                                      mpoly,
                                                      polynors,
-                                                     numPolys,
+                                                     polys_num,
                                                      clnors);
 
       MEM_freeN(vert_normals);
     }
     else {
-      loop_normals = MEM_calloc_arrayN((size_t)numLoops, sizeof(*loop_normals), __func__);
+      loop_normals = MEM_calloc_arrayN((size_t)loops_num, sizeof(*loop_normals), __func__);
 
       BKE_mesh_normals_loop_split(mvert,
                                   wn_data->vert_normals,
-                                  numVerts,
+                                  verts_num,
                                   medge,
-                                  numEdges,
+                                  edges_num,
                                   mloop,
                                   loop_normals,
-                                  numLoops,
+                                  loops_num,
                                   mpoly,
                                   polynors,
-                                  numPolys,
+                                  polys_num,
                                   true,
                                   split_angle,
                                   NULL,
                                   has_clnors ? clnors : NULL,
                                   loop_to_poly);
 
-      for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+      for (int ml_index = 0; ml_index < loops_num; ml_index++) {
         const int item_index = mloop[ml_index].v;
         if (!is_zero_v3(items_data[item_index].normal)) {
           copy_v3_v3(loop_normals[ml_index], items_data[item_index].normal);
@@ -423,15 +423,15 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
 
       BKE_mesh_normals_loop_custom_set(mvert,
                                        wn_data->vert_normals,
-                                       numVerts,
+                                       verts_num,
                                        medge,
-                                       numEdges,
+                                       edges_num,
                                        mloop,
                                        loop_normals,
-                                       numLoops,
+                                       loops_num,
                                        mpoly,
                                        polynors,
-                                       numPolys,
+                                       polys_num,
                                        clnors);
     }
   }
@@ -444,7 +444,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
 
 static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
 {
-  const int numPolys = wn_data->numPolys;
+  const int polys_num = wn_data->polys_num;
 
   MVert *mvert = wn_data->mvert;
   MLoop *mloop = wn_data->mloop;
@@ -453,15 +453,15 @@ static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *w
   MPoly *mp;
   int mp_index;
 
-  ModePair *face_area = MEM_malloc_arrayN((size_t)numPolys, sizeof(*face_area), __func__);
+  ModePair *face_area = MEM_malloc_arrayN((size_t)polys_num, sizeof(*face_area), __func__);
 
   ModePair *f_area = face_area;
-  for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++, f_area++) {
+  for (mp_index = 0, mp = mpoly; mp_index < polys_num; mp_index++, mp++, f_area++) {
     f_area->val = BKE_mesh_calc_poly_area(mp, &mloop[mp->loopstart], mvert);
     f_area->index = mp_index;
   }
 
-  qsort(face_area, numPolys, sizeof(*face_area), modepair_cmp_by_val_inverse);
+  qsort(face_area, polys_num, sizeof(*face_area), modepair_cmp_by_val_inverse);
 
   wn_data->mode_pair = face_area;
   apply_weights_vertex_normal(wnmd, wn_data);
@@ -469,8 +469,8 @@ static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *w
 
 static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
 {
-  const int numLoops = wn_data->numLoops;
-  const int numPolys = wn_data->numPolys;
+  const int loops_num = wn_data->loops_num;
+  const int polys_num = wn_data->polys_num;
 
   MVert *mvert = wn_data->mvert;
   MLoop *mloop = wn_data->mloop;
@@ -479,11 +479,11 @@ static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData
   MPoly *mp;
   int mp_index;
 
-  int *loop_to_poly = MEM_malloc_arrayN((size_t)numLoops, sizeof(*loop_to_poly), __func__);
+  int *loop_to_poly = MEM_malloc_arrayN((size_t)loops_num, sizeof(*loop_to_poly), __func__);
 
-  ModePair *corner_angle = MEM_malloc_arrayN((size_t)numLoops, sizeof(*corner_angle), __func__);
+  ModePair *corner_angle = MEM_malloc_arrayN((size_t)loops_num, sizeof(*corner_angle), __func__);
 
-  for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++) {
+  for (mp_index = 0, mp = mpoly; mp_index < polys_num; mp_index++, mp++) {
     MLoop *ml_start = &mloop[mp->loopstart];
 
     float *index_angle = MEM_malloc_arrayN((size_t)mp->totloop, sizeof(*index_angle), __func__);
@@ -501,7 +501,7 @@ static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData
     MEM_freeN(index_angle);
   }
 
-  qsort(corner_angle, numLoops, sizeof(*corner_angle), modepair_cmp_by_val_inverse);
+  qsort(corner_angle, loops_num, sizeof(*corner_angle), modepair_cmp_by_val_inverse);
 
   wn_data->loop_to_poly = loop_to_poly;
   wn_data->mode_pair = corner_angle;
@@ -510,8 +510,8 @@ static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData
 
 static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
 {
-  const int numLoops = wn_data->numLoops;
-  const int numPolys = wn_data->numPolys;
+  const int loops_num = wn_data->loops_num;
+  const int polys_num = wn_data->polys_num;
 
   MVert *mvert = wn_data->mvert;
   MLoop *mloop = wn_data->mloop;
@@ -520,11 +520,11 @@ static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalD
   MPoly *mp;
   int mp_index;
 
-  int *loop_to_poly = MEM_malloc_arrayN((size_t)numLoops, sizeof(*loop_to_poly), __func__);
+  int *loop_to_poly = MEM_malloc_arrayN((size_t)loops_num, sizeof(*loop_to_poly), __func__);
 
-  ModePair *combined = MEM_malloc_arrayN((size_t)numLoops, sizeof(*combined), __func__);
+  ModePair *combined = MEM_malloc_arrayN((size_t)loops_num, sizeof(*combined), __func__);
 
-  for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++) {
+  for (mp_index = 0, mp = mpoly; mp_index < polys_num; mp_index++, mp++) {
     MLoop *ml_start = &mloop[mp->loopstart];
 
     float face_area = BKE_mesh_calc_poly_area(mp, ml_start, mvert);
@@ -544,7 +544,7 @@ static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalD
     MEM_freeN(index_angle);
   }
 
-  qsort(combined, numLoops, sizeof(*combined), modepair_cmp_by_val_inverse);
+  qsort(combined, loops_num, sizeof(*combined), modepair_cmp_by_val_inverse);
 
   wn_data->loop_to_poly = loop_to_poly;
   wn_data->mode_pair = combined;
@@ -575,10 +575,10 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   Mesh *result;
   result = (Mesh *)BKE_id_copy_ex(NULL, &mesh->id, NULL, LIB_ID_COPY_LOCALIZE);
 
-  const int numVerts = result->totvert;
-  const int numEdges = result->totedge;
-  const int numLoops = result->totloop;
-  const int numPolys = result->totpoly;
+  const int verts_num = result->totvert;
+  const int edges_num = result->totedge;
+  const int loops_num = result->totloop;
+  const int polys_num = result->totpoly;
 
   MEdge *medge = result->medge;
   MPoly *mpoly = result->mpoly;
@@ -611,7 +611,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
    * it helps when generating clnor spaces and default normals. */
   const bool has_clnors = clnors != NULL;
   if (!clnors) {
-    clnors = CustomData_add_layer(ldata, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL, numLoops);
+    clnors = CustomData_add_layer(ldata, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL, loops_num);
   }
 
   MDeformVert *dvert;
@@ -619,10 +619,10 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   MOD_get_vgroup(ctx->object, mesh, wnmd->defgrp_name, &dvert, &defgrp_index);
 
   WeightedNormalData wn_data = {
-      .numVerts = numVerts,
-      .numEdges = numEdges,
-      .numLoops = numLoops,
-      .numPolys = numPolys,
+      .verts_num = verts_num,
+      .edges_num = edges_num,
+      .loops_num = loops_num,
+      .polys_num = polys_num,
 
       .mvert = mvert,
       .vert_normals = BKE_mesh_vertex_normals_ensure(result),