use booleans for bmesh api.

7 files changed, 101 insertions, 99 deletions

diff --git a/source/blender/bmesh/tools/BME_bevel.c b/source/blender/bmesh/tools/BME_bevel.c
index 5e1d58150fa..47b507603f4 100644
--- a/source/blender/bmesh/tools/BME_bevel.c
+++ b/source/blender/bmesh/tools/BME_bevel.c
@@ -90,7 +90,7 @@ static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BM
                                            float factor, float weight, float maxfactor, float *max)
 {
 	BME_TransData *vtd;
-	int is_new = 0;
+	int is_new = false;
 
 	if (v == NULL) {
 		return NULL;
@@ -100,7 +100,7 @@ static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BM
 		vtd = BLI_memarena_alloc(td->ma, sizeof(*vtd));
 		BLI_ghash_insert(td->gh, v, vtd);
 		td->len++;
-		is_new = 1;
+		is_new = true;
 	}
 
 	vtd->bm = bm;
@@ -151,12 +151,12 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
 {
 	BMFace *f;
 	BMEdge *e;
-	int done;
+	bool done;
 
 	if (v->e) {
-		done = FALSE;
+		done = false;
 		while (!done) {
-			done = TRUE;
+			done = true;
 			e = v->e; /*loop the edge looking for a edge to dissolve*/
 			do {
 				f = NULL;
@@ -164,14 +164,14 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
 					f = bmesh_jfke(bm, e->l->f, e->l->radial_next->f, e);
 				}
 				if (f) {
-					done = FALSE;
+					done = false;
 					break;
 				}
 				e = bmesh_disk_edge_next(e, v);
 			} while (e != v->e);
 		}
-		BM_vert_collapse_edge(bm, v->e, v, TRUE);
-		// bmesh_jekv(bm, v->e, v, FALSE);
+		BM_vert_collapse_edge(bm, v->e, v, true);
+		// bmesh_jekv(bm, v->e, v, false);
 	}
 }
 
@@ -539,18 +539,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
 		se = l->next->e;
 		jf = NULL;
 		if (kl->v == kv) {
-			BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, TRUE);
+			BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true);
 			ke = kl->e;
 			/* BMESH-TODO: jfke doesn't handle customdata */
 			jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e);
-			BM_vert_collapse_edge(bm, ke, kv, FALSE);
+			BM_vert_collapse_edge(bm, ke, kv, false);
 		}
 		else {
-			BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, TRUE);
+			BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true);
 			ke = kl->e;
 			/* BMESH-TODO: jfke doesn't handle customdata */
 			jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e);
-			BM_vert_collapse_edge(bm, ke, kv, FALSE);
+			BM_vert_collapse_edge(bm, ke, kv, false);
 		}
 		/* find saved loop pointer */
 		l = se->l;
@@ -585,18 +585,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
 		se = l->e;
 		jf = NULL;
 		if (kl->v == kv) {
-			BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, TRUE);
+			BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true);
 			ke = kl->e;
 			/* BMESH-TODO: jfke doesn't handle customdata */
 			jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e);
-			BM_vert_collapse_edge(bm, ke, kv, FALSE);
+			BM_vert_collapse_edge(bm, ke, kv, false);
 		}
 		else {
-			BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, TRUE);
+			BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true);
 			ke = kl->e;
 			/* BMESH-TODO: jfke doesn't handle customdata */
 			jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e);
-			BM_vert_collapse_edge(bm, ke, kv, FALSE);
+			BM_vert_collapse_edge(bm, ke, kv, false);
 		}
 		/* find saved loop pointer */
 		l = se->l;
@@ -607,7 +607,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
 	}
 
 	if (!BMO_elem_flag_test(bm, v1, BME_BEVEL_NONMAN) || !BMO_elem_flag_test(bm, v2, BME_BEVEL_NONMAN)) {
-		BM_face_split(bm, f, v2, v1, &l, e, TRUE);
+		BM_face_split(bm, f, v2, v1, &l, e, true);
 		BMO_elem_flag_enable(bm, l->e, BME_BEVEL_BEVEL);
 		l = l->radial_next;
 	}
@@ -636,7 +636,7 @@ static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
 	l = l->next->next;
 
 	/* "cut off" this corner */
-	/* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, TRUE);
+	/* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, true);
 
 	return l;
 }
@@ -1069,7 +1069,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
 	/* get rid of beveled edge */
 	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 		if (BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL) && BMO_elem_flag_test(bm, e, BME_BEVEL_ORIG)) {
-			BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE);
+			BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, true);
 		}
 	}
 
@@ -1083,9 +1083,9 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
 				if (l->v != v) l = l->next;
 				if (l2->v != v) l2 = l2->next;
 				if (l->f->len > 3)
-					BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, TRUE);  /* clip this corner off */
+					BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, true);  /* clip this corner off */
 				if (l2->f->len > 3)
-					BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, TRUE);  /* clip this corner off */
+					BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, true);  /* clip this corner off */
 				curedge = bmesh_disk_edge_next(curedge, v);
 			} while (curedge != v->e);
 			BME_Bevel_Dissolve_Disk(bm, v);
diff --git a/source/blender/bmesh/tools/bmesh_decimate.h b/source/blender/bmesh/tools/bmesh_decimate.h
index 4a557c20ae3..d3eaf1c6670 100644
--- a/source/blender/bmesh/tools/bmesh_decimate.h
+++ b/source/blender/bmesh/tools/bmesh_decimate.h
@@ -27,15 +27,15 @@
  *  \ingroup bmesh
  */
 
-void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const int do_triangulate);
+void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const bool do_triangulate);
 
-void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int tag_only);
+void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const bool tag_only);
 void BM_mesh_decimate_unsubdivide(BMesh *bm, const int iterations);
 
-void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries,
+void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries,
                                   BMVert **vinput_arr, const int vinput_len,
                                   BMEdge **einput_arr, const int einput_len);
-void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries);
+void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries);
 
 /* these weights are accumulated so too high values may reach 'inf' too quickly */
 #define BM_MESH_DECIM_WEIGHT_MAX 100000.0f
diff --git a/source/blender/bmesh/tools/bmesh_decimate_collapse.c b/source/blender/bmesh/tools/bmesh_decimate_collapse.c
index 794afb3e0d2..57a35d2f6a9 100644
--- a/source/blender/bmesh/tools/bmesh_decimate_collapse.c
+++ b/source/blender/bmesh/tools/bmesh_decimate_collapse.c
@@ -134,7 +134,7 @@ static void bm_decim_calc_target_co(BMEdge *e, float optimize_co[3],
 	}
 }
 
-static int bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_co[3])
+static bool bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_co[3])
 {
 	BMIter liter;
 	BMLoop *l;
@@ -175,13 +175,13 @@ static int bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_c
 				 * (first making it zero area, then flipping again) */
 				if (dot_v3v3(cross_exist, cross_optim) <= FLT_EPSILON) {
 					//printf("no flip\n");
-					return TRUE;
+					return true;
 				}
 			}
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
 static void bm_decim_build_edge_cost_single(BMEdge *e,
@@ -291,15 +291,15 @@ static void bm_decim_build_edge_cost(BMesh *bm,
  * collapsing edges so even has some advantage over decimating quads
  * directly.
  *
- * \return TRUE if any faces were triangulated.
+ * \return true if any faces were triangulated.
  */
 
-static int bm_decim_triangulate_begin(BMesh *bm)
+static bool bm_decim_triangulate_begin(BMesh *bm)
 {
 	BMIter iter;
 	BMFace *f;
-	// int has_quad;  // could optimize this a little
-	int has_cut = FALSE;
+	// bool has_quad;  // could optimize this a little
+	bool has_cut = false;
 
 	BLI_assert((bm->elem_index_dirty & BM_VERT) == 0);
 
@@ -345,7 +345,7 @@ static int bm_decim_triangulate_begin(BMesh *bm)
 			}
 
 #ifdef USE_SAFETY_CHECKS
-			if (BM_edge_exists(l_a->v, l_b->v) == FALSE)
+			if (BM_edge_exists(l_a->v, l_b->v) == false)
 #endif
 			{
 				BMFace *f_new;
@@ -355,7 +355,7 @@ static int bm_decim_triangulate_begin(BMesh *bm)
 				 * - if there is a quad that has a free standing edge joining it along
 				 * where we want to split the face, there isnt a good way we can handle this.
 				 * currently that edge will get removed when joining the tris back into a quad. */
-				f_new = BM_face_split(bm, f, l_a->v, l_b->v, &l_new, NULL, FALSE);
+				f_new = BM_face_split(bm, f, l_a->v, l_b->v, &l_new, NULL, false);
 
 				if (f_new) {
 					/* the value of this doesn't matter, only that the 2 loops match and have unique values */
@@ -370,7 +370,7 @@ static int bm_decim_triangulate_begin(BMesh *bm)
 					BM_face_normal_update(f);
 					BM_face_normal_update(f_new);
 
-					has_cut = TRUE;
+					has_cut = true;
 				}
 			}
 		}
@@ -410,15 +410,15 @@ static void bm_decim_triangulate_end(BMesh *bm)
 								BM_vert_in_edge(e, l_b->next->v) ? l_b->prev->v : l_b->next->v,
 							};
 
-							BLI_assert(ELEM3(vquad[0], vquad[1], vquad[2], vquad[3]) == FALSE);
-							BLI_assert(ELEM3(vquad[1], vquad[0], vquad[2], vquad[3]) == FALSE);
-							BLI_assert(ELEM3(vquad[2], vquad[1], vquad[0], vquad[3]) == FALSE);
-							BLI_assert(ELEM3(vquad[3], vquad[1], vquad[2], vquad[0]) == FALSE);
+							BLI_assert(ELEM3(vquad[0], vquad[1], vquad[2], vquad[3]) == false);
+							BLI_assert(ELEM3(vquad[1], vquad[0], vquad[2], vquad[3]) == false);
+							BLI_assert(ELEM3(vquad[2], vquad[1], vquad[0], vquad[3]) == false);
+							BLI_assert(ELEM3(vquad[3], vquad[1], vquad[2], vquad[0]) == false);
 
 							if (is_quad_convex_v3(vquad[0]->co, vquad[1]->co, vquad[2]->co, vquad[3]->co)) {
 								/* highly unlikely to fail, but prevents possible double-ups */
 								BMFace *f[2] = {l_a->f, l_b->f};
-								BM_faces_join(bm, f, 2, TRUE);
+								BM_faces_join(bm, f, 2, true);
 							}
 						}
 					}
@@ -445,7 +445,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle
 //#define USE_SEAM
 	/* these don't need to be updated, since they will get removed when the edge collapses */
 	BMLoop *l_clear, *l_other;
-	const int is_manifold = BM_edge_is_manifold(l->e);
+	const bool is_manifold = BM_edge_is_manifold(l->e);
 	int side;
 
 	/* l defines the vert to collapse into  */
@@ -467,7 +467,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle
 	/* now we have both corners of the face 'l->f' */
 	for (side = 0; side < 2; side++) {
 #ifdef USE_SEAM
-		int is_seam = FALSE;
+		bool is_seam = false;
 #endif
 		void *src[2];
 		BMFace *f_exit = is_manifold ? l->radial_next->f : NULL;
@@ -507,7 +507,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle
 
 #ifdef USE_SEAM
 			/* break out unless we find a match */
-			is_seam = TRUE;
+			is_seam = true;
 #endif
 
 			/* ok. we have a loop. now be smart with it! */
@@ -523,7 +523,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle
 					if (CustomData_data_equals(type, cd_src[0], cd_iter)) {
 						CustomData_bmesh_interp_n(&bm->ldata, cd_src, w, NULL, 2, l_iter->head.data, i);
 #ifdef USE_SEAM
-						is_seam = FALSE;
+						is_seam = false;
 #endif
 					}
 				}
@@ -598,7 +598,7 @@ BLI_INLINE int bm_edge_is_manifold_or_boundary(BMLoop *l)
 #endif
 }
 
-static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
+static bool bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
 {
 	/* simply check that there is no overlap between faces and edges of each vert,
 	 * (excluding the 2 faces attached to 'e' and 'e' its self) */
@@ -609,7 +609,7 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
 	e_iter = e_first;
 	do {
 		if (!bm_edge_is_manifold_or_boundary(e_iter->l)) {
-			return TRUE;
+			return true;
 		}
 		bm_edge_tag_disable(e_iter);
 	} while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v1)) != e_first);
@@ -617,7 +617,7 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
 	e_iter = e_first;
 	do {
 		if (!bm_edge_is_manifold_or_boundary(e_iter->l)) {
-			return TRUE;
+			return true;
 		}
 		bm_edge_tag_disable(e_iter);
 	} while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v2)) != e_first);
@@ -673,11 +673,11 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
 	e_iter = e_first;
 	do {
 		if (bm_edge_tag_test(e_iter)) {
-			return TRUE;
+			return true;
 		}
 	} while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v2)) != e_first);
 
-	return FALSE;
+	return false;
 }
 
 /**
@@ -690,13 +690,13 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first)
  * \param e_clear_other let caller know what edges we remove besides \a e_clear
  * \param customdata_flag merge factor, scales from 0 - 1 ('v_clear' -> 'v_other')
  */
-static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e_clear_other[2],
+static bool bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e_clear_other[2],
 #ifdef USE_CUSTOMDATA
-                            const CD_UseFlag customdata_flag,
-                            const float customdata_fac
+                             const CD_UseFlag customdata_flag,
+                             const float customdata_fac
 #else
-                            const CD_UseFlag UNUSED(customdata_flag),
-                            const float UNUSED(customdata_fac)
+                             const CD_UseFlag UNUSED(customdata_flag),
+                             const float UNUSED(customdata_fac)
 #endif
                             )
 {
@@ -708,11 +708,11 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e
 	if (BM_edge_is_manifold(e_clear)) {
 		BMLoop *l_a, *l_b;
 		BMEdge *e_a_other[2], *e_b_other[2];
-		int ok;
+		bool ok;
 
 		ok = BM_edge_loop_pair(e_clear, &l_a, &l_b);
 
-		BLI_assert(ok == TRUE);
+		BLI_assert(ok == true);
 		BLI_assert(l_a->f->len == 3);
 		BLI_assert(l_b->f->len == 3);
 
@@ -749,7 +749,7 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e
 		if (ELEM(e_a_other[0], e_b_other[0], e_b_other[1]) ||
 		    ELEM(e_a_other[1], e_b_other[0], e_b_other[1]))
 		{
-			return FALSE;
+			return false;
 		}
 
 		r_e_clear_other[0] = BM_elem_index_get(e_a_other[0]);
@@ -782,7 +782,7 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e
 
 		// BM_mesh_validate(bm);
 
-		return TRUE;
+		return true;
 	}
 	else if (BM_edge_is_boundary(e_clear)) {
 		/* same as above but only one triangle */
@@ -829,10 +829,10 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e
 
 		// BM_mesh_validate(bm);
 
-		return TRUE;
+		return true;
 	}
 	else {
-		return FALSE;
+		return false;
 	}
 }
 
@@ -869,7 +869,7 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e,
 	}
 
 	/* use for customdata merging */
-	if (LIKELY(compare_v3v3(e->v1->co, e->v2->co, FLT_EPSILON) == FALSE)) {
+	if (LIKELY(compare_v3v3(e->v1->co, e->v2->co, FLT_EPSILON) == false)) {
 		customdata_fac = line_point_factor_v3(optimize_co, e->v1->co, e->v2->co);
 #if 0
 		/* simple test for stupid collapse */
@@ -946,7 +946,7 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e,
 					else
 						e_outer = l->prev->e;
 
-					BLI_assert(BM_vert_in_edge(e_outer, l->v) == FALSE);
+					BLI_assert(BM_vert_in_edge(e_outer, l->v) == false);
 
 					bm_decim_build_edge_cost_single(e_outer, vquadrics, vweights, eheap, eheap_table);
 				}
@@ -972,14 +972,14 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e,
  * \param vweights Optional array of vertex  aligned weights [0 - 1],
  *        a vertex group is the usual source for this.
  */
-void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const int do_triangulate)
+void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const bool do_triangulate)
 {
 	Heap *eheap;             /* edge heap */
 	HeapNode **eheap_table;  /* edge index aligned table pointing to the eheap */
 	Quadric *vquadrics;      /* vert index aligned quadrics */
 	int tot_edge_orig;
 	int face_tot_target;
-	int use_triangulate;
+	bool use_triangulate;
 
 	CD_UseFlag customdata_flag = 0;
 
@@ -1015,7 +1015,7 @@ void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, c
 
 	/* iterative edge collapse and maintain the eheap */
 	while ((bm->totface > face_tot_target) &&
-	       (BLI_heap_is_empty(eheap) == FALSE) &&
+	       (BLI_heap_is_empty(eheap) == false) &&
 	       (BLI_heap_node_value(BLI_heap_top(eheap)) != COST_INVALID))
 	{
 		// const float value = BLI_heap_node_value(BLI_heap_top(eheap));
@@ -1033,7 +1033,7 @@ void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, c
 
 
 #ifdef USE_TRIANGULATE
-	if (do_triangulate == FALSE) {
+	if (do_triangulate == false) {
 		/* its possible we only had triangles, skip this step in that case */
 		if (LIKELY(use_triangulate)) {
 			/* temp convert quads to triangles */
diff --git a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c
index f67f01e4585..3a724769f2a 100644
--- a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c
+++ b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c
@@ -69,7 +69,7 @@ static int dissolve_elem_cmp(const void *a1, const void *a2)
 	return 0;
 }
 
-void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries,
+void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries,
                                   BMVert **vinput_arr, const int vinput_len,
                                   BMEdge **einput_arr, const int einput_len)
 {
@@ -117,7 +117,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int
 				BMFace *nf = BM_faces_join_pair(bm, e->l->f,
 				                                e->l->radial_next->f,
 				                                e,
-				                                FALSE); /* join faces */
+				                                false); /* join faces */
 
 				/* there may be some errors, we don't mind, just move on */
 				if (nf) {
@@ -148,7 +148,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int
 	for (i = bm->totedge - 1; i != -1; i--) {
 		e_iter = earray[i];
 
-		if (BM_edge_is_wire(e_iter) && (BM_elem_flag_test(e_iter, BM_ELEM_TAG) == FALSE)) {
+		if (BM_edge_is_wire(e_iter) && (BM_elem_flag_test(e_iter, BM_ELEM_TAG) == false)) {
 			/* edge has become wire */
 			int vidx_reverse;
 			BMVert *v1 = e_iter->v1;
@@ -179,7 +179,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int
 			if (LIKELY(v != NULL) &&
 			    BM_vert_edge_count(v) == 2)
 			{
-				BM_vert_collapse_edge(bm, v->e, v, TRUE); /* join edges */
+				BM_vert_collapse_edge(bm, v->e, v, true); /* join edges */
 			}
 		}
 	}
@@ -210,7 +210,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int
 				    /* check twice because cumulative effect could dissolve over angle limit */
 				    bm_vert_edge_face_angle(v) < angle_limit)
 				{
-					BMEdge *ne = BM_vert_collapse_edge(bm, v->e, v, TRUE); /* join edges */
+					BMEdge *ne = BM_vert_collapse_edge(bm, v->e, v, true); /* join edges */
 
 					if (ne && ne->l) {
 						BM_edge_normals_update(ne);
@@ -223,7 +223,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int
 	MEM_freeN(weight_elems);
 }
 
-void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries)
+void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries)
 {
 	int vinput_len;
 	int einput_len;
diff --git a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c
index 71c1cedbd5e..9dc4b596568 100644
--- a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c
+++ b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c
@@ -36,7 +36,7 @@
 #include "intern/bmesh_operators_private.h" /* own include */
 
 
-static int bm_vert_dissolve_fan_test(BMVert *v)
+static bool bm_vert_dissolve_fan_test(BMVert *v)
 {
 	/* check if we should walk over these verts */
 	BMIter iter;
@@ -61,21 +61,21 @@ static int bm_vert_dissolve_fan_test(BMVert *v)
 	}
 
 	if ((tot_edge == 4) && (tot_edge_boundary == 0) && (tot_edge_manifold == 4)) {
-		return TRUE;
+		return true;
 	}
 	else if ((tot_edge == 3) && (tot_edge_boundary == 0) && (tot_edge_manifold == 3)) {
-		return TRUE;
+		return true;
 	}
 	else if ((tot_edge == 3) && (tot_edge_boundary == 2) && (tot_edge_manifold == 1)) {
-		return TRUE;
+		return true;
 	}
 	else if ((tot_edge == 2) && (tot_edge_wire == 2)) {
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
-static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v)
+static bool bm_vert_dissolve_fan(BMesh *bm, BMVert *v)
 {
 	/* collapse under 2 conditions.
 	 * - vert connects to 4 manifold edges (and 4 faces).
@@ -110,7 +110,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v)
 	if (tot_edge == 2) {
 		/* check for 2 wire verts only */
 		if (tot_edge_wire == 2) {
-			return (BM_vert_collapse_edge(bm, v->e, v, TRUE) != NULL);
+			return (BM_vert_collapse_edge(bm, v->e, v, true) != NULL);
 		}
 	}
 	else if (tot_edge == 4) {
@@ -145,7 +145,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v)
 			if (l->f->len > 3) {
 				BMLoop *l_new;
 				BLI_assert(l->prev->v != l->next->v);
-				BM_face_split(bm, l->f, l->prev->v, l->next->v, &l_new, NULL, TRUE);
+				BM_face_split(bm, l->f, l->prev->v, l->next->v, &l_new, NULL, true);
 				BM_elem_flag_merge_into(l_new->e, l->e, l->prev->e);
 			}
 		}
@@ -153,7 +153,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v)
 		return BM_vert_dissolve(bm, v);
 	}
 
-	return FALSE;
+	return false;
 }
 
 enum {
@@ -170,7 +170,7 @@ enum {
 
 /**
  * \param tag_only so we can call this from an operator */
-void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int tag_only)
+void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const bool tag_only)
 {
 #ifdef USE_WALKER
 #  define ELE_VERT_TAG 1
@@ -191,14 +191,14 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int
 
 	/* if tag_only is set, we assyme the caller knows what verts to tag
 	 * needed for the operator */
-	if (tag_only == FALSE) {
+	if (tag_only == false) {
 		BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 			BM_elem_flag_enable(v, BM_ELEM_TAG);
 		}
 	}
 
 	for (iter_step = 0; iter_step < iterations; iter_step++) {
-		int iter_done;
+		bool iter_done;
 
 		BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 			if (BM_elem_flag_test(v, BM_ELEM_TAG) && bm_vert_dissolve_fan_test(v)) {
@@ -215,7 +215,7 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int
 
 
 		/* main loop, keep tagging until we can't tag any more islands */
-		while (TRUE) {
+		while (true) {
 #ifdef USE_WALKER
 			BMWalker walker;
 #else
@@ -273,7 +273,7 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int
 			vert_seek_b_tot = 0;
 			vert_seek_b[vert_seek_b_tot++] = v_first;
 
-			while (TRUE) {
+			while (true) {
 				BMEdge *e;
 
 				if ((offset + depth) % nth) {
@@ -318,14 +318,16 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int
 		}
 
 		/* now we tagged all verts -1 for removal, lets loop over and rebuild faces */
-		iter_done = FALSE;
+		iter_done = false;
 		BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 			if (BM_elem_index_get(v) == VERT_INDEX_DO_COLLAPSE) {
-				iter_done |= bm_vert_dissolve_fan(bm, v);
+				if (bm_vert_dissolve_fan(bm, v)) {
+					iter_done = true;
+				}
 			}
 		}
 
-		if (iter_done == FALSE) {
+		if (iter_done == false) {
 			break;
 		}
 	}
@@ -340,5 +342,5 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int
 
 void BM_mesh_decimate_unsubdivide(BMesh *bm, const int iterations)
 {
-	BM_mesh_decimate_unsubdivide_ex(bm, iterations, FALSE);
+	BM_mesh_decimate_unsubdivide_ex(bm, iterations, false);
 }
diff --git a/source/blender/bmesh/tools/bmesh_edgesplit.c b/source/blender/bmesh/tools/bmesh_edgesplit.c
index b6a8c7985d6..1d3f973dbc0 100644
--- a/source/blender/bmesh/tools/bmesh_edgesplit.c
+++ b/source/blender/bmesh/tools/bmesh_edgesplit.c
@@ -98,14 +98,14 @@ static void bm_edgesplit_validate_seams(BMesh *bm)
 	MEM_freeN(vtouch);
 }
 
-void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only)
+void BM_mesh_edgesplit(BMesh *bm, const bool use_verts, const bool tag_only)
 {
 	BMIter iter;
 	BMEdge *e;
 
 
-	if (tag_only == FALSE) {
-		BM_mesh_elem_hflag_enable_all(bm, BM_EDGE | (use_verts ? BM_VERT : 0), BM_ELEM_TAG, FALSE);
+	if (tag_only == false) {
+		BM_mesh_elem_hflag_enable_all(bm, BM_EDGE | (use_verts ? BM_VERT : 0), BM_ELEM_TAG, false);
 	}
 
 	if (use_verts) {
@@ -117,8 +117,8 @@ void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only)
 		 */
 		BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 			if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
-				if (UNLIKELY(((BM_elem_flag_test(e->v1, BM_ELEM_TAG) == FALSE) &&
-				              (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == FALSE))))
+				if (UNLIKELY(((BM_elem_flag_test(e->v1, BM_ELEM_TAG) == false) &&
+				              (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == false))))
 				{
 					BM_elem_flag_enable(e->v1, BM_ELEM_TAG);
 					BM_elem_flag_enable(e->v2, BM_ELEM_TAG);
@@ -146,10 +146,10 @@ void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only)
 
 	if (use_verts) {
 		BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-			if (BM_elem_flag_test(e->v1, BM_ELEM_TAG) == FALSE) {
+			if (BM_elem_flag_test(e->v1, BM_ELEM_TAG) == false) {
 				BM_elem_flag_disable(e->v1, BM_ELEM_TAG);
 			}
-			if (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == FALSE) {
+			if (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == false) {
 				BM_elem_flag_disable(e->v2, BM_ELEM_TAG);
 			}
 		}
diff --git a/source/blender/bmesh/tools/bmesh_edgesplit.h b/source/blender/bmesh/tools/bmesh_edgesplit.h
index 687fdac0e00..8c1231dd794 100644
--- a/source/blender/bmesh/tools/bmesh_edgesplit.h
+++ b/source/blender/bmesh/tools/bmesh_edgesplit.h
@@ -27,6 +27,6 @@
  *  \ingroup bmesh
  */
 
-void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only);
+void BM_mesh_edgesplit(BMesh *bm, const bool use_verts, const bool tag_only);
 
 #endif /* __BMESH_EDGESPLIT_H__ */