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

Also rename DNA struct members.

1 files changed, 74 insertions, 69 deletions

diff --git a/source/blender/modifiers/intern/MOD_laplaciansmooth.c b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
index effe2a5af90..11abe9a4d0a 100644
--- a/source/blender/modifiers/intern/MOD_laplaciansmooth.c
+++ b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
@@ -45,12 +45,12 @@ struct BLaplacianSystem {
   float *ring_areas;    /* Total area per ring. */
   float *vlengths;      /* Total sum of lengths(edges) per vertex. */
   float *vweights;      /* Total sum of weights per vertex. */
-  int numEdges;         /* Number of edges. */
-  int numLoops;         /* Number of edges. */
-  int numPolys;         /* Number of faces. */
-  int numVerts;         /* Number of verts. */
-  short *numNeFa;       /* Number of neighbors faces around vertex. */
-  short *numNeEd;       /* Number of neighbors Edges around vertex. */
+  int edges_num;        /* Number of edges. */
+  int loops_num;        /* Number of edges. */
+  int polys_num;        /* Number of faces. */
+  int verts_num;        /* Number of verts. */
+  short *ne_fa_num;     /* Number of neighbors faces around vertex. */
+  short *ne_ed_num;     /* Number of neighbors Edges around vertex. */
   bool *zerola;         /* Is zero area or length. */
 
   /* Pointers to data. */
@@ -71,7 +71,7 @@ static bool is_disabled(const struct Scene *scene, ModifierData *md, bool useRen
 static float compute_volume(const float center[3],
                             float (*vertexCos)[3],
                             const MPoly *mpoly,
-                            int numPolys,
+                            int polys_num,
                             const MLoop *mloop);
 static LaplacianSystem *init_laplacian_system(int a_numEdges,
                                               int a_numPolys,
@@ -89,8 +89,8 @@ static void delete_laplacian_system(LaplacianSystem *sys)
 {
   MEM_SAFE_FREE(sys->eweights);
   MEM_SAFE_FREE(sys->fweights);
-  MEM_SAFE_FREE(sys->numNeEd);
-  MEM_SAFE_FREE(sys->numNeFa);
+  MEM_SAFE_FREE(sys->ne_ed_num);
+  MEM_SAFE_FREE(sys->ne_fa_num);
   MEM_SAFE_FREE(sys->ring_areas);
   MEM_SAFE_FREE(sys->vlengths);
   MEM_SAFE_FREE(sys->vweights);
@@ -108,14 +108,14 @@ static void delete_laplacian_system(LaplacianSystem *sys)
 
 static void memset_laplacian_system(LaplacianSystem *sys, int val)
 {
-  memset(sys->eweights, val, sizeof(float) * sys->numEdges);
-  memset(sys->fweights, val, sizeof(float[3]) * sys->numLoops);
-  memset(sys->numNeEd, val, sizeof(short) * sys->numVerts);
-  memset(sys->numNeFa, val, sizeof(short) * sys->numVerts);
-  memset(sys->ring_areas, val, sizeof(float) * sys->numVerts);
-  memset(sys->vlengths, val, sizeof(float) * sys->numVerts);
-  memset(sys->vweights, val, sizeof(float) * sys->numVerts);
-  memset(sys->zerola, val, sizeof(bool) * sys->numVerts);
+  memset(sys->eweights, val, sizeof(float) * sys->edges_num);
+  memset(sys->fweights, val, sizeof(float[3]) * sys->loops_num);
+  memset(sys->ne_ed_num, val, sizeof(short) * sys->verts_num);
+  memset(sys->ne_fa_num, val, sizeof(short) * sys->verts_num);
+  memset(sys->ring_areas, val, sizeof(float) * sys->verts_num);
+  memset(sys->vlengths, val, sizeof(float) * sys->verts_num);
+  memset(sys->vweights, val, sizeof(float) * sys->verts_num);
+  memset(sys->zerola, val, sizeof(bool) * sys->verts_num);
 }
 
 static LaplacianSystem *init_laplacian_system(int a_numEdges,
@@ -125,19 +125,19 @@ static LaplacianSystem *init_laplacian_system(int a_numEdges,
 {
   LaplacianSystem *sys;
   sys = MEM_callocN(sizeof(LaplacianSystem), "ModLaplSmoothSystem");
-  sys->numEdges = a_numEdges;
-  sys->numPolys = a_numPolys;
-  sys->numLoops = a_numLoops;
-  sys->numVerts = a_numVerts;
-
-  sys->eweights = MEM_calloc_arrayN(sys->numEdges, sizeof(float), __func__);
-  sys->fweights = MEM_calloc_arrayN(sys->numLoops, sizeof(float[3]), __func__);
-  sys->numNeEd = MEM_calloc_arrayN(sys->numVerts, sizeof(short), __func__);
-  sys->numNeFa = MEM_calloc_arrayN(sys->numVerts, sizeof(short), __func__);
-  sys->ring_areas = MEM_calloc_arrayN(sys->numVerts, sizeof(float), __func__);
-  sys->vlengths = MEM_calloc_arrayN(sys->numVerts, sizeof(float), __func__);
-  sys->vweights = MEM_calloc_arrayN(sys->numVerts, sizeof(float), __func__);
-  sys->zerola = MEM_calloc_arrayN(sys->numVerts, sizeof(bool), __func__);
+  sys->edges_num = a_numEdges;
+  sys->polys_num = a_numPolys;
+  sys->loops_num = a_numLoops;
+  sys->verts_num = a_numVerts;
+
+  sys->eweights = MEM_calloc_arrayN(sys->edges_num, sizeof(float), __func__);
+  sys->fweights = MEM_calloc_arrayN(sys->loops_num, sizeof(float[3]), __func__);
+  sys->ne_ed_num = MEM_calloc_arrayN(sys->verts_num, sizeof(short), __func__);
+  sys->ne_fa_num = MEM_calloc_arrayN(sys->verts_num, sizeof(short), __func__);
+  sys->ring_areas = MEM_calloc_arrayN(sys->verts_num, sizeof(float), __func__);
+  sys->vlengths = MEM_calloc_arrayN(sys->verts_num, sizeof(float), __func__);
+  sys->vweights = MEM_calloc_arrayN(sys->verts_num, sizeof(float), __func__);
+  sys->zerola = MEM_calloc_arrayN(sys->verts_num, sizeof(bool), __func__);
 
   return sys;
 }
@@ -145,13 +145,13 @@ static LaplacianSystem *init_laplacian_system(int a_numEdges,
 static float compute_volume(const float center[3],
                             float (*vertexCos)[3],
                             const MPoly *mpoly,
-                            int numPolys,
+                            int polys_num,
                             const MLoop *mloop)
 {
   int i;
   float vol = 0.0f;
 
-  for (i = 0; i < numPolys; i++) {
+  for (i = 0; i < polys_num; i++) {
     const MPoly *mp = &mpoly[i];
     const MLoop *l_first = &mloop[mp->loopstart];
     const MLoop *l_prev = l_first + 1;
@@ -174,7 +174,7 @@ static void volume_preservation(LaplacianSystem *sys, float vini, float vend, sh
 
   if (vend != 0.0f) {
     beta = pow(vini / vend, 1.0f / 3.0f);
-    for (i = 0; i < sys->numVerts; i++) {
+    for (i = 0; i < sys->verts_num; i++) {
       if (flag & MOD_LAPLACIANSMOOTH_X) {
         sys->vertexCos[i][0] = (sys->vertexCos[i][0] - sys->vert_centroid[0]) * beta +
                                sys->vert_centroid[0];
@@ -199,15 +199,15 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
   int i;
   uint idv1, idv2;
 
-  for (i = 0; i < sys->numEdges; i++) {
+  for (i = 0; i < sys->edges_num; i++) {
     idv1 = sys->medges[i].v1;
     idv2 = sys->medges[i].v2;
 
     v1 = sys->vertexCos[idv1];
     v2 = sys->vertexCos[idv2];
 
-    sys->numNeEd[idv1] = sys->numNeEd[idv1] + 1;
-    sys->numNeEd[idv2] = sys->numNeEd[idv2] + 1;
+    sys->ne_ed_num[idv1] = sys->ne_ed_num[idv1] + 1;
+    sys->ne_ed_num[idv2] = sys->ne_ed_num[idv2] + 1;
     w1 = len_v3v3(v1, v2);
     if (w1 < sys->min_area) {
       sys->zerola[idv1] = true;
@@ -220,7 +220,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
     sys->eweights[i] = w1;
   }
 
-  for (i = 0; i < sys->numPolys; i++) {
+  for (i = 0; i < sys->polys_num; i++) {
     const MPoly *mp = &sys->mpoly[i];
     const MLoop *l_next = &sys->mloop[mp->loopstart];
     const MLoop *l_term = l_next + mp->totloop;
@@ -233,7 +233,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
       const float *v_next = sys->vertexCos[l_next->v];
       const uint l_curr_index = l_curr - sys->mloop;
 
-      sys->numNeFa[l_curr->v] += 1;
+      sys->ne_fa_num[l_curr->v] += 1;
 
       areaf = area_tri_v3(v_prev, v_curr, v_next);
 
@@ -258,11 +258,12 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
       sys->vweights[l_prev->v] += w1 + w2;
     }
   }
-  for (i = 0; i < sys->numEdges; i++) {
+  for (i = 0; i < sys->edges_num; i++) {
     idv1 = sys->medges[i].v1;
     idv2 = sys->medges[i].v2;
     /* if is boundary, apply scale-dependent umbrella operator only with neighbors in boundary */
-    if (sys->numNeEd[idv1] != sys->numNeFa[idv1] && sys->numNeEd[idv2] != sys->numNeFa[idv2]) {
+    if (sys->ne_ed_num[idv1] != sys->ne_fa_num[idv1] &&
+        sys->ne_ed_num[idv2] != sys->ne_fa_num[idv2]) {
       sys->vlengths[idv1] += sys->eweights[i];
       sys->vlengths[idv2] += sys->eweights[i];
     }
@@ -274,7 +275,7 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
   int i;
   uint idv1, idv2;
 
-  for (i = 0; i < sys->numPolys; i++) {
+  for (i = 0; i < sys->polys_num; i++) {
     const MPoly *mp = &sys->mpoly[i];
     const MLoop *l_next = &sys->mloop[mp->loopstart];
     const MLoop *l_term = l_next + mp->totloop;
@@ -285,7 +286,8 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
       const uint l_curr_index = l_curr - sys->mloop;
 
       /* Is ring if number of faces == number of edges around vertex. */
-      if (sys->numNeEd[l_curr->v] == sys->numNeFa[l_curr->v] && sys->zerola[l_curr->v] == false) {
+      if (sys->ne_ed_num[l_curr->v] == sys->ne_fa_num[l_curr->v] &&
+          sys->zerola[l_curr->v] == false) {
         EIG_linear_solver_matrix_add(sys->context,
                                      l_curr->v,
                                      l_next->v,
@@ -295,7 +297,8 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
                                      l_prev->v,
                                      sys->fweights[l_curr_index][1] * sys->vweights[l_curr->v]);
       }
-      if (sys->numNeEd[l_next->v] == sys->numNeFa[l_next->v] && sys->zerola[l_next->v] == false) {
+      if (sys->ne_ed_num[l_next->v] == sys->ne_fa_num[l_next->v] &&
+          sys->zerola[l_next->v] == false) {
         EIG_linear_solver_matrix_add(sys->context,
                                      l_next->v,
                                      l_curr->v,
@@ -305,7 +308,8 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
                                      l_prev->v,
                                      sys->fweights[l_curr_index][0] * sys->vweights[l_next->v]);
       }
-      if (sys->numNeEd[l_prev->v] == sys->numNeFa[l_prev->v] && sys->zerola[l_prev->v] == false) {
+      if (sys->ne_ed_num[l_prev->v] == sys->ne_fa_num[l_prev->v] &&
+          sys->zerola[l_prev->v] == false) {
         EIG_linear_solver_matrix_add(sys->context,
                                      l_prev->v,
                                      l_curr->v,
@@ -318,12 +322,13 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
     }
   }
 
-  for (i = 0; i < sys->numEdges; i++) {
+  for (i = 0; i < sys->edges_num; i++) {
     idv1 = sys->medges[i].v1;
     idv2 = sys->medges[i].v2;
     /* Is boundary */
-    if (sys->numNeEd[idv1] != sys->numNeFa[idv1] && sys->numNeEd[idv2] != sys->numNeFa[idv2] &&
-        sys->zerola[idv1] == false && sys->zerola[idv2] == false) {
+    if (sys->ne_ed_num[idv1] != sys->ne_fa_num[idv1] &&
+        sys->ne_ed_num[idv2] != sys->ne_fa_num[idv2] && sys->zerola[idv1] == false &&
+        sys->zerola[idv2] == false) {
       EIG_linear_solver_matrix_add(
           sys->context, idv1, idv2, sys->eweights[i] * sys->vlengths[idv1]);
       EIG_linear_solver_matrix_add(
@@ -340,12 +345,12 @@ static void validate_solution(LaplacianSystem *sys, short flag, float lambda, fl
 
   if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
     vini = compute_volume(
-        sys->vert_centroid, sys->vertexCos, sys->mpoly, sys->numPolys, sys->mloop);
+        sys->vert_centroid, sys->vertexCos, sys->mpoly, sys->polys_num, sys->mloop);
   }
-  for (i = 0; i < sys->numVerts; i++) {
+  for (i = 0; i < sys->verts_num; i++) {
     if (sys->zerola[i] == false) {
-      lam = sys->numNeEd[i] == sys->numNeFa[i] ? (lambda >= 0.0f ? 1.0f : -1.0f) :
-                                                 (lambda_border >= 0.0f ? 1.0f : -1.0f);
+      lam = sys->ne_ed_num[i] == sys->ne_fa_num[i] ? (lambda >= 0.0f ? 1.0f : -1.0f) :
+                                                     (lambda_border >= 0.0f ? 1.0f : -1.0f);
       if (flag & MOD_LAPLACIANSMOOTH_X) {
         sys->vertexCos[i][0] += lam * ((float)EIG_linear_solver_variable_get(sys->context, 0, i) -
                                        sys->vertexCos[i][0]);
@@ -362,13 +367,13 @@ static void validate_solution(LaplacianSystem *sys, short flag, float lambda, fl
   }
   if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
     vend = compute_volume(
-        sys->vert_centroid, sys->vertexCos, sys->mpoly, sys->numPolys, sys->mloop);
+        sys->vert_centroid, sys->vertexCos, sys->mpoly, sys->polys_num, sys->mloop);
     volume_preservation(sys, vini, vend, flag);
   }
 }
 
 static void laplaciansmoothModifier_do(
-    LaplacianSmoothModifierData *smd, Object *ob, Mesh *mesh, float (*vertexCos)[3], int numVerts)
+    LaplacianSmoothModifierData *smd, Object *ob, Mesh *mesh, float (*vertexCos)[3], int verts_num)
 {
   LaplacianSystem *sys;
   MDeformVert *dvert = NULL;
@@ -378,7 +383,7 @@ static void laplaciansmoothModifier_do(
   int defgrp_index;
   const bool invert_vgroup = (smd->flag & MOD_LAPLACIANSMOOTH_INVERT_VGROUP) != 0;
 
-  sys = init_laplacian_system(mesh->totedge, mesh->totpoly, mesh->totloop, numVerts);
+  sys = init_laplacian_system(mesh->totedge, mesh->totpoly, mesh->totloop, verts_num);
   if (!sys) {
     return;
   }
@@ -395,12 +400,12 @@ static void laplaciansmoothModifier_do(
   sys->vert_centroid[2] = 0.0f;
   memset_laplacian_system(sys, 0);
 
-  sys->context = EIG_linear_least_squares_solver_new(numVerts, numVerts, 3);
+  sys->context = EIG_linear_least_squares_solver_new(verts_num, verts_num, 3);
 
   init_laplacian_matrix(sys);
 
   for (iter = 0; iter < smd->repeat; iter++) {
-    for (i = 0; i < numVerts; i++) {
+    for (i = 0; i < verts_num; i++) {
       EIG_linear_solver_variable_set(sys->context, 0, i, vertexCos[i][0]);
       EIG_linear_solver_variable_set(sys->context, 1, i, vertexCos[i][1]);
       EIG_linear_solver_variable_set(sys->context, 2, i, vertexCos[i][2]);
@@ -408,12 +413,12 @@ static void laplaciansmoothModifier_do(
         add_v3_v3(sys->vert_centroid, vertexCos[i]);
       }
     }
-    if (iter == 0 && numVerts > 0) {
-      mul_v3_fl(sys->vert_centroid, 1.0f / (float)numVerts);
+    if (iter == 0 && verts_num > 0) {
+      mul_v3_fl(sys->vert_centroid, 1.0f / (float)verts_num);
     }
 
     dv = dvert;
-    for (i = 0; i < numVerts; i++) {
+    for (i = 0; i < verts_num; i++) {
       EIG_linear_solver_right_hand_side_add(sys->context, 0, i, vertexCos[i][0]);
       EIG_linear_solver_right_hand_side_add(sys->context, 1, i, vertexCos[i][1]);
       EIG_linear_solver_right_hand_side_add(sys->context, 2, i, vertexCos[i][2]);
@@ -433,7 +438,7 @@ static void laplaciansmoothModifier_do(
             sys->vweights[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda) * wpaint / w;
             w = sys->vlengths[i];
             sys->vlengths[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda_border) * wpaint * 2.0f / w;
-            if (sys->numNeEd[i] == sys->numNeFa[i]) {
+            if (sys->ne_ed_num[i] == sys->ne_fa_num[i]) {
               EIG_linear_solver_matrix_add(sys->context, i, i, 1.0f + fabsf(smd->lambda) * wpaint);
             }
             else {
@@ -447,7 +452,7 @@ static void laplaciansmoothModifier_do(
             w = sys->vlengths[i];
             sys->vlengths[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda_border) * wpaint * 2.0f / w;
 
-            if (sys->numNeEd[i] == sys->numNeFa[i]) {
+            if (sys->ne_ed_num[i] == sys->ne_fa_num[i]) {
               EIG_linear_solver_matrix_add(sys->context,
                                            i,
                                            i,
@@ -522,18 +527,18 @@ static void deformVerts(ModifierData *md,
                         const ModifierEvalContext *ctx,
                         Mesh *mesh,
                         float (*vertexCos)[3],
-                        int numVerts)
+                        int verts_num)
 {
   Mesh *mesh_src;
 
-  if (numVerts == 0) {
+  if (verts_num == 0) {
     return;
   }
 
-  mesh_src = MOD_deform_mesh_eval_get(ctx->object, NULL, mesh, NULL, numVerts, false, false);
+  mesh_src = MOD_deform_mesh_eval_get(ctx->object, NULL, mesh, NULL, verts_num, false, false);
 
   laplaciansmoothModifier_do(
-      (LaplacianSmoothModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
+      (LaplacianSmoothModifierData *)md, ctx->object, mesh_src, vertexCos, verts_num);
 
   if (!ELEM(mesh_src, NULL, mesh)) {
     BKE_id_free(NULL, mesh_src);
@@ -545,15 +550,15 @@ static void deformVertsEM(ModifierData *md,
                           struct BMEditMesh *editData,
                           Mesh *mesh,
                           float (*vertexCos)[3],
-                          int numVerts)
+                          int verts_num)
 {
   Mesh *mesh_src;
 
-  if (numVerts == 0) {
+  if (verts_num == 0) {
     return;
   }
 
-  mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, NULL, numVerts, false, false);
+  mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, NULL, verts_num, false, false);
 
   /* TODO(Campbell): use edit-mode data only (remove this line). */
   if (mesh_src != NULL) {
@@ -561,7 +566,7 @@ static void deformVertsEM(ModifierData *md,
   }
 
   laplaciansmoothModifier_do(
-      (LaplacianSmoothModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
+      (LaplacianSmoothModifierData *)md, ctx->object, mesh_src, vertexCos, verts_num);
 
   if (!ELEM(mesh_src, NULL, mesh)) {
     BKE_id_free(NULL, mesh_src);