Cleanup: Unindent if statements in sculpt tools code

This removes indentations from if statements by converting them to early
returns and continue.
Most of the code of brushes and tools has loops with a full indented
body inside of an if, which was also copied into some of the new tools.

Reviewed By: JacquesLucke

Differential Revision: https://developer.blender.org/D10333

1 files changed, 164 insertions, 145 deletions

diff --git a/source/blender/editors/sculpt_paint/sculpt_boundary.c b/source/blender/editors/sculpt_paint/sculpt_boundary.c
index 0cfb6f17adb..fca19c04b98 100644
--- a/source/blender/editors/sculpt_paint/sculpt_boundary.c
+++ b/source/blender/editors/sculpt_paint/sculpt_boundary.c
@@ -227,19 +227,19 @@ static bool boundary_floodfill_cb(
 {
   BoundaryFloodFillData *data = userdata;
   SculptBoundary *boundary = data->boundary;
-  if (SCULPT_vertex_is_boundary(ss, to_v)) {
-    const float edge_len = len_v3v3(SCULPT_vertex_co_get(ss, from_v),
-                                    SCULPT_vertex_co_get(ss, to_v));
-    const float distance_boundary_to_dst = boundary->distance ?
-                                               boundary->distance[from_v] + edge_len :
-                                               0.0f;
-    sculpt_boundary_index_add(boundary, to_v, distance_boundary_to_dst, data->included_vertices);
-    if (!is_duplicate) {
-      sculpt_boundary_preview_edge_add(boundary, from_v, to_v);
-    }
-    return sculpt_boundary_is_vertex_in_editable_boundary(ss, to_v);
+  if (!SCULPT_vertex_is_boundary(ss, to_v)) {
+    return false;
+  }
+  const float edge_len = len_v3v3(SCULPT_vertex_co_get(ss, from_v),
+                                  SCULPT_vertex_co_get(ss, to_v));
+  const float distance_boundary_to_dst = boundary->distance ?
+                                             boundary->distance[from_v] + edge_len :
+                                             0.0f;
+  sculpt_boundary_index_add(boundary, to_v, distance_boundary_to_dst, data->included_vertices);
+  if (!is_duplicate) {
+    sculpt_boundary_preview_edge_add(boundary, from_v, to_v);
   }
-  return false;
+  return sculpt_boundary_is_vertex_in_editable_boundary(ss, to_v);
 }
 
 static void sculpt_boundary_indices_init(SculptSession *ss,
@@ -360,49 +360,50 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
       SculptVertexNeighborIter ni;
       SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, from_v, ni) {
         const bool is_visible = SCULPT_vertex_visible_get(ss, ni.index);
-        if (is_visible &&
-            boundary->edit_info[ni.index].num_propagation_steps == BOUNDARY_STEPS_NONE) {
-          boundary->edit_info[ni.index].original_vertex =
-              boundary->edit_info[from_v].original_vertex;
+        if (!is_visible ||
+            boundary->edit_info[ni.index].num_propagation_steps != BOUNDARY_STEPS_NONE) {
+          continue;
+        }
+        boundary->edit_info[ni.index].original_vertex =
+            boundary->edit_info[from_v].original_vertex;
 
-          BLI_BITMAP_ENABLE(visited_vertices, ni.index);
+        BLI_BITMAP_ENABLE(visited_vertices, ni.index);
 
-          if (ni.is_duplicate) {
-            /* Grids duplicates handling. */
-            boundary->edit_info[ni.index].num_propagation_steps =
-                boundary->edit_info[from_v].num_propagation_steps;
-          }
-          else {
-            boundary->edit_info[ni.index].num_propagation_steps =
-                boundary->edit_info[from_v].num_propagation_steps + 1;
-
-            BLI_gsqueue_push(next_iteration, &ni.index);
-
-            /* When copying the data to the neighbor for the next iteration, it has to be copied to
-             * all its duplicates too. This is because it is not possible to know if the updated
-             * neighbor or one if its uninitialized duplicates is going to come first in order to
-             * copy the data in the from_v neighbor iterator. */
-            if (has_duplicates) {
-              SculptVertexNeighborIter ni_duplis;
-              SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, ni.index, ni_duplis) {
-                if (ni_duplis.is_duplicate) {
-                  boundary->edit_info[ni_duplis.index].original_vertex =
-                      boundary->edit_info[from_v].original_vertex;
-                  boundary->edit_info[ni_duplis.index].num_propagation_steps =
-                      boundary->edit_info[from_v].num_propagation_steps + 1;
-                }
+        if (ni.is_duplicate) {
+          /* Grids duplicates handling. */
+          boundary->edit_info[ni.index].num_propagation_steps =
+              boundary->edit_info[from_v].num_propagation_steps;
+        }
+        else {
+          boundary->edit_info[ni.index].num_propagation_steps =
+              boundary->edit_info[from_v].num_propagation_steps + 1;
+
+          BLI_gsqueue_push(next_iteration, &ni.index);
+
+          /* When copying the data to the neighbor for the next iteration, it has to be copied to
+           * all its duplicates too. This is because it is not possible to know if the updated
+           * neighbor or one if its uninitialized duplicates is going to come first in order to
+           * copy the data in the from_v neighbor iterator. */
+          if (has_duplicates) {
+            SculptVertexNeighborIter ni_duplis;
+            SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, ni.index, ni_duplis) {
+              if (ni_duplis.is_duplicate) {
+                boundary->edit_info[ni_duplis.index].original_vertex =
+                    boundary->edit_info[from_v].original_vertex;
+                boundary->edit_info[ni_duplis.index].num_propagation_steps =
+                    boundary->edit_info[from_v].num_propagation_steps + 1;
               }
-              SCULPT_VERTEX_NEIGHBORS_ITER_END(ni_duplis);
             }
+            SCULPT_VERTEX_NEIGHBORS_ITER_END(ni_duplis);
+          }
 
-            /* Check the distance using the vertex that was propagated from the initial vertex that
-             * was used to initialize the boundary. */
-            if (boundary->edit_info[from_v].original_vertex == initial_vertex) {
-              boundary->pivot_vertex = ni.index;
-              copy_v3_v3(boundary->initial_pivot_position, SCULPT_vertex_co_get(ss, ni.index));
-              accum_distance += len_v3v3(SCULPT_vertex_co_get(ss, from_v),
-                                         SCULPT_vertex_co_get(ss, ni.index));
-            }
+          /* Check the distance using the vertex that was propagated from the initial vertex that
+           * was used to initialize the boundary. */
+          if (boundary->edit_info[from_v].original_vertex == initial_vertex) {
+            boundary->pivot_vertex = ni.index;
+            copy_v3_v3(boundary->initial_pivot_position, SCULPT_vertex_co_get(ss, ni.index));
+            accum_distance += len_v3v3(SCULPT_vertex_co_get(ss, from_v),
+                                       SCULPT_vertex_co_get(ss, ni.index));
           }
         }
       }
@@ -552,28 +553,30 @@ static void sculpt_boundary_bend_data_init(SculptSession *ss, SculptBoundary *bo
       totvert, 3 * sizeof(float), "pivot positions");
 
   for (int i = 0; i < totvert; i++) {
-    if (boundary->edit_info[i].num_propagation_steps == boundary->max_propagation_steps) {
-      float dir[3];
-      float normal[3];
-      SCULPT_vertex_normal_get(ss, i, normal);
-      sub_v3_v3v3(dir,
-                  SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
-                  SCULPT_vertex_co_get(ss, i));
-      cross_v3_v3v3(
-          boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex], dir, normal);
-      normalize_v3(boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
-      copy_v3_v3(boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex],
-                 SCULPT_vertex_co_get(ss, i));
+    if (boundary->edit_info[i].num_propagation_steps != boundary->max_propagation_steps) {
+      continue;
     }
+    float dir[3];
+    float normal[3];
+    SCULPT_vertex_normal_get(ss, i, normal);
+    sub_v3_v3v3(dir,
+                SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
+                SCULPT_vertex_co_get(ss, i));
+    cross_v3_v3v3(
+        boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex], dir, normal);
+    normalize_v3(boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
+    copy_v3_v3(boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex],
+               SCULPT_vertex_co_get(ss, i));
   }
 
   for (int i = 0; i < totvert; i++) {
-    if (boundary->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
-      copy_v3_v3(boundary->bend.pivot_positions[i],
-                 boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex]);
-      copy_v3_v3(boundary->bend.pivot_rotation_axis[i],
-                 boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
+    if (boundary->edit_info[i].num_propagation_steps == BOUNDARY_STEPS_NONE) {
+      continue;
     }
+    copy_v3_v3(boundary->bend.pivot_positions[i],
+               boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex]);
+    copy_v3_v3(boundary->bend.pivot_rotation_axis[i],
+               boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
   }
 }
 
@@ -583,19 +586,20 @@ static void sculpt_boundary_slide_data_init(SculptSession *ss, SculptBoundary *b
   boundary->slide.directions = MEM_calloc_arrayN(totvert, 3 * sizeof(float), "slide directions");
 
   for (int i = 0; i < totvert; i++) {
-    if (boundary->edit_info[i].num_propagation_steps == boundary->max_propagation_steps) {
-      sub_v3_v3v3(boundary->slide.directions[boundary->edit_info[i].original_vertex],
-                  SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
-                  SCULPT_vertex_co_get(ss, i));
-      normalize_v3(boundary->slide.directions[boundary->edit_info[i].original_vertex]);
+    if (boundary->edit_info[i].num_propagation_steps != boundary->max_propagation_steps) {
     }
+    sub_v3_v3v3(boundary->slide.directions[boundary->edit_info[i].original_vertex],
+                SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
+                SCULPT_vertex_co_get(ss, i));
+    normalize_v3(boundary->slide.directions[boundary->edit_info[i].original_vertex]);
   }
 
   for (int i = 0; i < totvert; i++) {
-    if (boundary->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
-      copy_v3_v3(boundary->slide.directions[i],
-                 boundary->slide.directions[boundary->edit_info[i].original_vertex]);
+    if (boundary->edit_info[i].num_propagation_steps == BOUNDARY_STEPS_NONE) {
+      continue;
     }
+    copy_v3_v3(boundary->slide.directions[i],
+               boundary->slide.directions[boundary->edit_info[i].original_vertex]);
   }
 }
 
@@ -662,24 +666,27 @@ static void do_boundary_brush_bend_task_cb_ex(void *__restrict userdata,
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
+    if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+      continue;
+    }
 
-    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
-      SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(
-              orig_data.co, boundary->initial_vertex_position, symm)) {
-        const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
-        const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
-        float t_orig_co[3];
-        float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
-        sub_v3_v3v3(t_orig_co, orig_data.co, boundary->bend.pivot_positions[vd.index]);
-        rotate_v3_v3v3fl(target_co,
-                         t_orig_co,
-                         boundary->bend.pivot_rotation_axis[vd.index],
-                         angle * boundary->edit_info[vd.index].strength_factor * mask * automask);
-        add_v3_v3(target_co, boundary->bend.pivot_positions[vd.index]);
-      }
+    SCULPT_orig_vert_data_update(&orig_data, &vd);
+    if (!SCULPT_check_vertex_pivot_symmetry(
+            orig_data.co, boundary->initial_vertex_position, symm)) {
+      continue;
     }
 
+    const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
+    const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
+    float t_orig_co[3];
+    float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
+    sub_v3_v3v3(t_orig_co, orig_data.co, boundary->bend.pivot_positions[vd.index]);
+    rotate_v3_v3v3fl(target_co,
+                     t_orig_co,
+                     boundary->bend.pivot_rotation_axis[vd.index],
+                     angle * boundary->edit_info[vd.index].strength_factor * mask * automask);
+    add_v3_v3(target_co, boundary->bend.pivot_positions[vd.index]);
+
     if (vd.mvert) {
       vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
     }
@@ -708,22 +715,25 @@ static void do_boundary_brush_slide_task_cb_ex(void *__restrict userdata,
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
+    if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+      continue;
+    }
 
-    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
-      SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(
-              orig_data.co, boundary->initial_vertex_position, symm)) {
-        const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
-        const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
-        float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
-        madd_v3_v3v3fl(target_co,
-                       orig_data.co,
-                       boundary->slide.directions[vd.index],
-                       boundary->edit_info[vd.index].strength_factor * disp * mask * automask *
-                           strength);
-      }
+    SCULPT_orig_vert_data_update(&orig_data, &vd);
+    if (!SCULPT_check_vertex_pivot_symmetry(
+            orig_data.co, boundary->initial_vertex_position, symm)) {
+      continue;
     }
 
+    const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
+    const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
+    float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
+    madd_v3_v3v3fl(target_co,
+                   orig_data.co,
+                   boundary->slide.directions[vd.index],
+                   boundary->edit_info[vd.index].strength_factor * disp * mask * automask *
+                       strength);
+
     if (vd.mvert) {
       vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
     }
@@ -752,24 +762,27 @@ static void do_boundary_brush_inflate_task_cb_ex(void *__restrict userdata,
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
+    if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+      continue;
+    }
 
-    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
-      SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(
-              orig_data.co, boundary->initial_vertex_position, symm)) {
-        const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
-        const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
-        float normal[3];
-        normal_short_to_float_v3(normal, orig_data.no);
-        float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
-        madd_v3_v3v3fl(target_co,
-                       orig_data.co,
-                       normal,
-                       boundary->edit_info[vd.index].strength_factor * disp * mask * automask *
-                           strength);
-      }
+    SCULPT_orig_vert_data_update(&orig_data, &vd);
+    if (!SCULPT_check_vertex_pivot_symmetry(
+            orig_data.co, boundary->initial_vertex_position, symm)) {
+      continue;
     }
 
+    const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
+    const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
+    float normal[3];
+    normal_short_to_float_v3(normal, orig_data.no);
+    float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
+    madd_v3_v3v3fl(target_co,
+                   orig_data.co,
+                   normal,
+                   boundary->edit_info[vd.index].strength_factor * disp * mask * automask *
+                       strength);
+
     if (vd.mvert) {
       vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
     }
@@ -796,21 +809,24 @@ static void do_boundary_brush_grab_task_cb_ex(void *__restrict userdata,
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
+    if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+      continue;
+    }
 
-    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
-      SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(
-              orig_data.co, boundary->initial_vertex_position, symm)) {
-        const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
-        const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
-        float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
-        madd_v3_v3v3fl(target_co,
-                       orig_data.co,
-                       ss->cache->grab_delta_symmetry,
-                       boundary->edit_info[vd.index].strength_factor * mask * automask * strength);
-      }
+    SCULPT_orig_vert_data_update(&orig_data, &vd);
+    if (!SCULPT_check_vertex_pivot_symmetry(
+            orig_data.co, boundary->initial_vertex_position, symm)) {
+      continue;
     }
 
+    const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
+    const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
+    float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
+    madd_v3_v3v3fl(target_co,
+                   orig_data.co,
+                   ss->cache->grab_delta_symmetry,
+                   boundary->edit_info[vd.index].strength_factor * mask * automask * strength);
+
     if (vd.mvert) {
       vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
     }
@@ -845,24 +861,27 @@ static void do_boundary_brush_twist_task_cb_ex(void *__restrict userdata,
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
+    if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+      continue;
+    }
 
-    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
-      SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(
-              orig_data.co, boundary->initial_vertex_position, symm)) {
-        const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
-        const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
-        float t_orig_co[3];
-        float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
-        sub_v3_v3v3(t_orig_co, orig_data.co, boundary->twist.pivot_position);
-        rotate_v3_v3v3fl(target_co,
-                         t_orig_co,
-                         boundary->twist.rotation_axis,
-                         angle * mask * automask * boundary->edit_info[vd.index].strength_factor);
-        add_v3_v3(target_co, boundary->twist.pivot_position);
-      }
+    SCULPT_orig_vert_data_update(&orig_data, &vd);
+    if (!SCULPT_check_vertex_pivot_symmetry(
+            orig_data.co, boundary->initial_vertex_position, symm)) {
+      continue;
     }
 
+    const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
+    const float automask = SCULPT_automasking_factor_get(ss->cache->automasking, ss, vd.index);
+    float t_orig_co[3];
+    float *target_co = SCULPT_brush_deform_target_vertex_co_get(ss, brush->deform_target, &vd);
+    sub_v3_v3v3(t_orig_co, orig_data.co, boundary->twist.pivot_position);
+    rotate_v3_v3v3fl(target_co,
+                     t_orig_co,
+                     boundary->twist.rotation_axis,
+                     angle * mask * automask * boundary->edit_info[vd.index].strength_factor);
+    add_v3_v3(target_co, boundary->twist.pivot_position);
+
     if (vd.mvert) {
       vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
     }