Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / mball_tessellate.c
index 3ca46b7be61c03839eace59295a49620e68640ff..b008eca225830431a15a82835fb8e728cf5a8014 100644 (file)
@@ -172,13 +172,16 @@ static unsigned int partition_mainb(
   div *= 2.0f;
 
   while (1) {
   div *= 2.0f;
 
   while (1) {
-    while (i < j && div > (mainb[i]->bb->vec[6][s] + mainb[i]->bb->vec[0][s]))
+    while (i < j && div > (mainb[i]->bb->vec[6][s] + mainb[i]->bb->vec[0][s])) {
       i++;
       i++;
-    while (j > i && div < (mainb[j]->bb->vec[6][s] + mainb[j]->bb->vec[0][s]))
+    }
+    while (j > i && div < (mainb[j]->bb->vec[6][s] + mainb[j]->bb->vec[0][s])) {
       j--;
       j--;
+    }
 
 
-    if (i >= j)
+    if (i >= j) {
       break;
       break;
+    }
 
     SWAP(MetaElem *, mainb[i], mainb[j]);
     i++;
 
     SWAP(MetaElem *, mainb[i], mainb[j]);
     i++;
@@ -212,10 +215,12 @@ static void build_bvh_spatial(PROCESS *process,
   dim[2] = allbox->max[2] - allbox->min[2];
 
   s = 0;
   dim[2] = allbox->max[2] - allbox->min[2];
 
   s = 0;
-  if (dim[1] > dim[0] && dim[1] > dim[2])
+  if (dim[1] > dim[0] && dim[1] > dim[2]) {
     s = 1;
     s = 1;
-  else if (dim[2] > dim[1] && dim[2] > dim[0])
+  }
+  else if (dim[2] > dim[1] && dim[2] > dim[0]) {
     s = 2;
     s = 2;
+  }
 
   div = allbox->min[s] + (dim[s] / 2.0f);
 
 
   div = allbox->min[s] + (dim[s] / 2.0f);
 
@@ -316,28 +321,37 @@ static float densfunc(const MetaElem *ball, float x, float y, float z)
       /* do nothing */
       break;
     case MB_CUBE:
       /* do nothing */
       break;
     case MB_CUBE:
-      if (dvec[2] > ball->expz)
+      if (dvec[2] > ball->expz) {
         dvec[2] -= ball->expz;
         dvec[2] -= ball->expz;
-      else if (dvec[2] < -ball->expz)
+      }
+      else if (dvec[2] < -ball->expz) {
         dvec[2] += ball->expz;
         dvec[2] += ball->expz;
-      else
+      }
+      else {
         dvec[2] = 0.0;
         dvec[2] = 0.0;
+      }
       ATTR_FALLTHROUGH;
     case MB_PLANE:
       ATTR_FALLTHROUGH;
     case MB_PLANE:
-      if (dvec[1] > ball->expy)
+      if (dvec[1] > ball->expy) {
         dvec[1] -= ball->expy;
         dvec[1] -= ball->expy;
-      else if (dvec[1] < -ball->expy)
+      }
+      else if (dvec[1] < -ball->expy) {
         dvec[1] += ball->expy;
         dvec[1] += ball->expy;
-      else
+      }
+      else {
         dvec[1] = 0.0;
         dvec[1] = 0.0;
+      }
       ATTR_FALLTHROUGH;
     case MB_TUBE:
       ATTR_FALLTHROUGH;
     case MB_TUBE:
-      if (dvec[0] > ball->expx)
+      if (dvec[0] > ball->expx) {
         dvec[0] -= ball->expx;
         dvec[0] -= ball->expx;
-      else if (dvec[0] < -ball->expx)
+      }
+      else if (dvec[0] < -ball->expx) {
         dvec[0] += ball->expx;
         dvec[0] += ball->expx;
-      else
+      }
+      else {
         dvec[0] = 0.0;
         dvec[0] = 0.0;
+      }
       break;
     case MB_ELIPSOID:
       dvec[0] /= ball->expx;
       break;
     case MB_ELIPSOID:
       dvec[0] /= ball->expx;
@@ -347,28 +361,37 @@ static float densfunc(const MetaElem *ball, float x, float y, float z)
 
     /* *** deprecated, could be removed?, do-versioned at least *** */
     case MB_TUBEX:
 
     /* *** deprecated, could be removed?, do-versioned at least *** */
     case MB_TUBEX:
-      if (dvec[0] > ball->len)
+      if (dvec[0] > ball->len) {
         dvec[0] -= ball->len;
         dvec[0] -= ball->len;
-      else if (dvec[0] < -ball->len)
+      }
+      else if (dvec[0] < -ball->len) {
         dvec[0] += ball->len;
         dvec[0] += ball->len;
-      else
+      }
+      else {
         dvec[0] = 0.0;
         dvec[0] = 0.0;
+      }
       break;
     case MB_TUBEY:
       break;
     case MB_TUBEY:
-      if (dvec[1] > ball->len)
+      if (dvec[1] > ball->len) {
         dvec[1] -= ball->len;
         dvec[1] -= ball->len;
-      else if (dvec[1] < -ball->len)
+      }
+      else if (dvec[1] < -ball->len) {
         dvec[1] += ball->len;
         dvec[1] += ball->len;
-      else
+      }
+      else {
         dvec[1] = 0.0;
         dvec[1] = 0.0;
+      }
       break;
     case MB_TUBEZ:
       break;
     case MB_TUBEZ:
-      if (dvec[2] > ball->len)
+      if (dvec[2] > ball->len) {
         dvec[2] -= ball->len;
         dvec[2] -= ball->len;
-      else if (dvec[2] < -ball->len)
+      }
+      else if (dvec[2] < -ball->len) {
         dvec[2] += ball->len;
         dvec[2] += ball->len;
-      else
+      }
+      else {
         dvec[2] = 0.0;
         dvec[2] = 0.0;
+      }
       break;
       /* *** end deprecated *** */
   }
       break;
       /* *** end deprecated *** */
   }
@@ -399,10 +422,12 @@ static float metaball(PROCESS *process, float x, float y, float z)
     for (i = 0; i < 2; i++) {
       if ((node->bb[i].min[0] <= x) && (node->bb[i].max[0] >= x) && (node->bb[i].min[1] <= y) &&
           (node->bb[i].max[1] >= y) && (node->bb[i].min[2] <= z) && (node->bb[i].max[2] >= z)) {
     for (i = 0; i < 2; i++) {
       if ((node->bb[i].min[0] <= x) && (node->bb[i].max[0] >= x) && (node->bb[i].min[1] <= y) &&
           (node->bb[i].max[1] >= y) && (node->bb[i].min[2] <= z) && (node->bb[i].max[2] >= z)) {
-        if (node->child[i])
+        if (node->child[i]) {
           process->bvh_queue[front++] = node->child[i];
           process->bvh_queue[front++] = node->child[i];
-        else
+        }
+        else {
           dens += densfunc(node->bb[i].ml, x, y, z);
           dens += densfunc(node->bb[i].ml, x, y, z);
+        }
       }
     }
   }
       }
     }
   }
@@ -466,18 +491,24 @@ static void make_face(PROCESS *process, int i1, int i2, int i3, int i4)
 /* Frees allocated memory */
 static void freepolygonize(PROCESS *process)
 {
 /* Frees allocated memory */
 static void freepolygonize(PROCESS *process)
 {
-  if (process->corners)
+  if (process->corners) {
     MEM_freeN(process->corners);
     MEM_freeN(process->corners);
-  if (process->edges)
+  }
+  if (process->edges) {
     MEM_freeN(process->edges);
     MEM_freeN(process->edges);
-  if (process->centers)
+  }
+  if (process->centers) {
     MEM_freeN(process->centers);
     MEM_freeN(process->centers);
-  if (process->mainb)
+  }
+  if (process->mainb) {
     MEM_freeN(process->mainb);
     MEM_freeN(process->mainb);
-  if (process->bvh_queue)
+  }
+  if (process->bvh_queue) {
     MEM_freeN(process->bvh_queue);
     MEM_freeN(process->bvh_queue);
-  if (process->pgn_elements)
+  }
+  if (process->pgn_elements) {
     BLI_memarena_free(process->pgn_elements);
     BLI_memarena_free(process->pgn_elements);
+  }
 }
 
 /* **************** POLYGONIZATION ************************ */
 }
 
 /* **************** POLYGONIZATION ************************ */
@@ -577,18 +608,24 @@ static void docube(PROCESS *process, CUBE *cube)
   }
 
   /* Using faces[] table, adds neighbouring cube if surface intersects face in this direction. */
   }
 
   /* Using faces[] table, adds neighbouring cube if surface intersects face in this direction. */
-  if (MB_BIT(faces[index], 0))
+  if (MB_BIT(faces[index], 0)) {
     add_cube(process, cube->i - 1, cube->j, cube->k);
     add_cube(process, cube->i - 1, cube->j, cube->k);
-  if (MB_BIT(faces[index], 1))
+  }
+  if (MB_BIT(faces[index], 1)) {
     add_cube(process, cube->i + 1, cube->j, cube->k);
     add_cube(process, cube->i + 1, cube->j, cube->k);
-  if (MB_BIT(faces[index], 2))
+  }
+  if (MB_BIT(faces[index], 2)) {
     add_cube(process, cube->i, cube->j - 1, cube->k);
     add_cube(process, cube->i, cube->j - 1, cube->k);
-  if (MB_BIT(faces[index], 3))
+  }
+  if (MB_BIT(faces[index], 3)) {
     add_cube(process, cube->i, cube->j + 1, cube->k);
     add_cube(process, cube->i, cube->j + 1, cube->k);
-  if (MB_BIT(faces[index], 4))
+  }
+  if (MB_BIT(faces[index], 4)) {
     add_cube(process, cube->i, cube->j, cube->k - 1);
     add_cube(process, cube->i, cube->j, cube->k - 1);
-  if (MB_BIT(faces[index], 5))
+  }
+  if (MB_BIT(faces[index], 5)) {
     add_cube(process, cube->i, cube->j, cube->k + 1);
     add_cube(process, cube->i, cube->j, cube->k + 1);
+  }
 
   /* Using cubetable[], determines polygons for output. */
   for (polys = cubetable[index]; polys; polys = polys->next) {
 
   /* Using cubetable[], determines polygons for output. */
   for (polys = cubetable[index]; polys; polys = polys->next) {
@@ -719,15 +756,18 @@ static void makecubetable(void)
   static bool is_done = false;
   int i, e, c, done[12], pos[8];
 
   static bool is_done = false;
   int i, e, c, done[12], pos[8];
 
-  if (is_done)
+  if (is_done) {
     return;
     return;
+  }
   is_done = true;
 
   for (i = 0; i < 256; i++) {
   is_done = true;
 
   for (i = 0; i < 256; i++) {
-    for (e = 0; e < 12; e++)
+    for (e = 0; e < 12; e++) {
       done[e] = 0;
       done[e] = 0;
-    for (c = 0; c < 8; c++)
+    }
+    for (c = 0; c < 8; c++) {
       pos[c] = MB_BIT(i, c);
       pos[c] = MB_BIT(i, c);
+    }
     for (e = 0; e < 12; e++) {
       if (!done[e] && (pos[corner1[e]] != pos[corner2[e]])) {
         INTLIST *ints = NULL;
     for (e = 0; e < 12; e++) {
       if (!done[e] && (pos[corner1[e]] != pos[corner2[e]])) {
         INTLIST *ints = NULL;
@@ -747,8 +787,9 @@ static void makecubetable(void)
             ints->i = edge;
             ints->next = tmp; /* add edge to head of list */
 
             ints->i = edge;
             ints->next = tmp; /* add edge to head of list */
 
-            if (edge == start)
+            if (edge == start) {
               break;
               break;
+            }
             face = otherface(edge, face);
           }
         }
             face = otherface(edge, face);
           }
         }
@@ -766,18 +807,24 @@ static void makecubetable(void)
       INTLIST *edges;
 
       for (edges = polys->list; edges; edges = edges->next) {
       INTLIST *edges;
 
       for (edges = polys->list; edges; edges = edges->next) {
-        if (edges->i == LB || edges->i == LT || edges->i == LN || edges->i == LF)
+        if (edges->i == LB || edges->i == LT || edges->i == LN || edges->i == LF) {
           faces[i] |= 1 << L;
           faces[i] |= 1 << L;
-        if (edges->i == RB || edges->i == RT || edges->i == RN || edges->i == RF)
+        }
+        if (edges->i == RB || edges->i == RT || edges->i == RN || edges->i == RF) {
           faces[i] |= 1 << R;
           faces[i] |= 1 << R;
-        if (edges->i == LB || edges->i == RB || edges->i == BN || edges->i == BF)
+        }
+        if (edges->i == LB || edges->i == RB || edges->i == BN || edges->i == BF) {
           faces[i] |= 1 << B;
           faces[i] |= 1 << B;
-        if (edges->i == LT || edges->i == RT || edges->i == TN || edges->i == TF)
+        }
+        if (edges->i == LT || edges->i == RT || edges->i == TN || edges->i == TF) {
           faces[i] |= 1 << T;
           faces[i] |= 1 << T;
-        if (edges->i == LN || edges->i == RN || edges->i == BN || edges->i == TN)
+        }
+        if (edges->i == LN || edges->i == RN || edges->i == BN || edges->i == TN) {
           faces[i] |= 1 << N;
           faces[i] |= 1 << N;
-        if (edges->i == LF || edges->i == RF || edges->i == BF || edges->i == TF)
+        }
+        if (edges->i == LF || edges->i == RF || edges->i == BF || edges->i == TF) {
           faces[i] |= 1 << F;
           faces[i] |= 1 << F;
+        }
       }
     }
   }
       }
     }
   }
@@ -822,8 +869,9 @@ static int setcenter(PROCESS *process, CENTERLIST *table[], const int i, const i
   q = table[index];
 
   for (l = q; l != NULL; l = l->next) {
   q = table[index];
 
   for (l = q; l != NULL; l = l->next) {
-    if (l->i == i && l->j == j && l->k == k)
+    if (l->i == i && l->j == j && l->k == k) {
       return 1;
       return 1;
+    }
   }
 
   newc = BLI_memarena_alloc(process->pgn_elements, sizeof(CENTERLIST));
   }
 
   newc = BLI_memarena_alloc(process->pgn_elements, sizeof(CENTERLIST));
@@ -940,8 +988,9 @@ static int vertid(PROCESS *process, const CORNER *c1, const CORNER *c2)
   float v[3], no[3];
   int vid = getedge(process->edges, c1->i, c1->j, c1->k, c2->i, c2->j, c2->k);
 
   float v[3], no[3];
   int vid = getedge(process->edges, c1->i, c1->j, c1->k, c2->i, c2->j, c2->k);
 
-  if (vid != -1)
+  if (vid != -1) {
     return vid; /* previously computed */
     return vid; /* previously computed */
+  }
 
   converge(process, c1, c2, v); /* position */
 
 
   converge(process, c1, c2, v); /* position */
 
@@ -1020,9 +1069,10 @@ static void add_cube(PROCESS *process, int i, int j, int k)
     ncube->cube.k = k;
 
     /* set corners of initial cube: */
     ncube->cube.k = k;
 
     /* set corners of initial cube: */
-    for (n = 0; n < 8; n++)
+    for (n = 0; n < 8; n++) {
       ncube->cube.corners[n] = setcorner(
           process, i + MB_BIT(n, 2), j + MB_BIT(n, 1), k + MB_BIT(n, 0));
       ncube->cube.corners[n] = setcorner(
           process, i + MB_BIT(n, 2), j + MB_BIT(n, 1), k + MB_BIT(n, 0));
+    }
   }
 }
 
   }
 }
 
@@ -1157,10 +1207,12 @@ static void init_meta(Depsgraph *depsgraph, PROCESS *process, Scene *scene, Obje
       if (bob == ob && (base->flag_legacy & OB_FROMDUPLI) == 0) {
         mb = ob->data;
 
       if (bob == ob && (base->flag_legacy & OB_FROMDUPLI) == 0) {
         mb = ob->data;
 
-        if (mb->editelems)
+        if (mb->editelems) {
           ml = mb->editelems->first;
           ml = mb->editelems->first;
-        else
+        }
+        else {
           ml = mb->elems.first;
           ml = mb->elems.first;
+        }
       }
       else {
         char name[MAX_ID_NAME];
       }
       else {
         char name[MAX_ID_NAME];
@@ -1170,10 +1222,12 @@ static void init_meta(Depsgraph *depsgraph, PROCESS *process, Scene *scene, Obje
         if (STREQ(obname, name)) {
           mb = bob->data;
 
         if (STREQ(obname, name)) {
           mb = bob->data;
 
-          if (mb->editelems)
+          if (mb->editelems) {
             ml = mb->editelems->first;
             ml = mb->editelems->first;
-          else
+          }
+          else {
             ml = mb->elems.first;
             ml = mb->elems.first;
+          }
         }
       }
 
         }
       }
 
@@ -1216,14 +1270,17 @@ static void init_meta(Depsgraph *depsgraph, PROCESS *process, Scene *scene, Obje
 
             /* too big stiffness seems only ugly due to linear interpolation
              * no need to have possibility for too big stiffness */
 
             /* too big stiffness seems only ugly due to linear interpolation
              * no need to have possibility for too big stiffness */
-            if (ml->s > 10.0f)
+            if (ml->s > 10.0f) {
               new_ml->s = 10.0f;
               new_ml->s = 10.0f;
-            else
+            }
+            else {
               new_ml->s = ml->s;
               new_ml->s = ml->s;
+            }
 
             /* if metaball is negative, set stiffness negative */
 
             /* if metaball is negative, set stiffness negative */
-            if (new_ml->flag & MB_NEGATIVE)
+            if (new_ml->flag & MB_NEGATIVE) {
               new_ml->s = -new_ml->s;
               new_ml->s = -new_ml->s;
+            }
 
             /* Translation of MetaElem */
             unit_m4(pos);
 
             /* Translation of MetaElem */
             unit_m4(pos);
@@ -1278,8 +1335,9 @@ static void init_meta(Depsgraph *depsgraph, PROCESS *process, Scene *scene, Obje
             copy_v3_fl3(new_ml->bb->vec[7], -expx, +expy, +expz); /* 7 */
 
             /* transformation of Metalem bb */
             copy_v3_fl3(new_ml->bb->vec[7], -expx, +expy, +expz); /* 7 */
 
             /* transformation of Metalem bb */
-            for (i = 0; i < 8; i++)
+            for (i = 0; i < 8; i++) {
               mul_m4_v3((float(*)[4])new_ml->mat, new_ml->bb->vec[i]);
               mul_m4_v3((float(*)[4])new_ml->mat, new_ml->bb->vec[i]);
+            }
 
             /* find max and min of transformed bb */
             INIT_MINMAX(tempmin, tempmax);
 
             /* find max and min of transformed bb */
             INIT_MINMAX(tempmin, tempmax);
@@ -1308,8 +1366,9 @@ static void init_meta(Depsgraph *depsgraph, PROCESS *process, Scene *scene, Obje
   if (process->totelem > 0) {
     copy_v3_v3(process->allbb.min, process->mainb[0]->bb->vec[0]);
     copy_v3_v3(process->allbb.max, process->mainb[0]->bb->vec[6]);
   if (process->totelem > 0) {
     copy_v3_v3(process->allbb.min, process->mainb[0]->bb->vec[0]);
     copy_v3_v3(process->allbb.max, process->mainb[0]->bb->vec[6]);
-    for (i = 1; i < process->totelem; i++)
+    for (i = 1; i < process->totelem; i++) {
       make_box_union(process->mainb[i]->bb, &process->allbb, &process->allbb);
       make_box_union(process->mainb[i]->bb, &process->allbb, &process->allbb);
+    }
   }
 }
 
   }
 }
 
@@ -1325,19 +1384,25 @@ void BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob, ListBa
 
   process.thresh = mb->thresh;
 
 
   process.thresh = mb->thresh;
 
-  if (process.thresh < 0.001f)
+  if (process.thresh < 0.001f) {
     process.converge_res = 16;
     process.converge_res = 16;
-  else if (process.thresh < 0.01f)
+  }
+  else if (process.thresh < 0.01f) {
     process.converge_res = 8;
     process.converge_res = 8;
-  else if (process.thresh < 0.1f)
+  }
+  else if (process.thresh < 0.1f) {
     process.converge_res = 4;
     process.converge_res = 4;
-  else
+  }
+  else {
     process.converge_res = 2;
     process.converge_res = 2;
+  }
 
 
-  if (is_render && (mb->flag == MB_UPDATE_NEVER))
+  if (is_render && (mb->flag == MB_UPDATE_NEVER)) {
     return;
     return;
-  if ((G.moving & (G_TRANSFORM_OBJ | G_TRANSFORM_EDIT)) && mb->flag == MB_UPDATE_FAST)
+  }
+  if ((G.moving & (G_TRANSFORM_OBJ | G_TRANSFORM_EDIT)) && mb->flag == MB_UPDATE_FAST) {
     return;
     return;
+  }
 
   if (is_render) {
     process.size = mb->rendersize;
 
   if (is_render) {
     process.size = mb->rendersize;