ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 1149 insertions, 1107 deletions

diff --git a/source/blender/editors/mesh/editmesh_utils.c b/source/blender/editors/mesh/editmesh_utils.c
index f86a2388f87..1cb550fccc4 100644
--- a/source/blender/editors/mesh/editmesh_utils.c
+++ b/source/blender/editors/mesh/editmesh_utils.c
@@ -44,7 +44,7 @@
 
 #include "DEG_depsgraph.h"
 
-#include "BKE_object.h"  /* XXX. only for EDBM_mesh_load(). */
+#include "BKE_object.h" /* XXX. only for EDBM_mesh_load(). */
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -53,7 +53,7 @@
 #include "ED_screen.h"
 #include "ED_view3d.h"
 
-#include "mesh_intern.h"  /* own include */
+#include "mesh_intern.h" /* own include */
 
 /* -------------------------------------------------------------------- */
 /** \name Redo API
@@ -66,47 +66,47 @@
 
 BMBackup EDBM_redo_state_store(BMEditMesh *em)
 {
-	BMBackup backup;
-	backup.bmcopy = BM_mesh_copy(em->bm);
-	return backup;
+  BMBackup backup;
+  backup.bmcopy = BM_mesh_copy(em->bm);
+  return backup;
 }
 
 void EDBM_redo_state_restore(BMBackup backup, BMEditMesh *em, int recalctess)
 {
-	BMesh *tmpbm;
-	if (!em || !backup.bmcopy) {
-		return;
-	}
-
-	BM_mesh_data_free(em->bm);
-	tmpbm = BM_mesh_copy(backup.bmcopy);
-	*em->bm = *tmpbm;
-	MEM_freeN(tmpbm);
-	tmpbm = NULL;
-
-	if (recalctess) {
-		BKE_editmesh_tessface_calc(em);
-	}
+  BMesh *tmpbm;
+  if (!em || !backup.bmcopy) {
+    return;
+  }
+
+  BM_mesh_data_free(em->bm);
+  tmpbm = BM_mesh_copy(backup.bmcopy);
+  *em->bm = *tmpbm;
+  MEM_freeN(tmpbm);
+  tmpbm = NULL;
+
+  if (recalctess) {
+    BKE_editmesh_tessface_calc(em);
+  }
 }
 
 void EDBM_redo_state_free(BMBackup *backup, BMEditMesh *em, int recalctess)
 {
-	if (em && backup->bmcopy) {
-		BM_mesh_data_free(em->bm);
-		*em->bm = *backup->bmcopy;
-	}
-	else if (backup->bmcopy) {
-		BM_mesh_data_free(backup->bmcopy);
-	}
-
-	if (backup->bmcopy) {
-		MEM_freeN(backup->bmcopy);
-	}
-	backup->bmcopy = NULL;
-
-	if (recalctess && em) {
-		BKE_editmesh_tessface_calc(em);
-	}
+  if (em && backup->bmcopy) {
+    BM_mesh_data_free(em->bm);
+    *em->bm = *backup->bmcopy;
+  }
+  else if (backup->bmcopy) {
+    BM_mesh_data_free(backup->bmcopy);
+  }
+
+  if (backup->bmcopy) {
+    MEM_freeN(backup->bmcopy);
+  }
+  backup->bmcopy = NULL;
+
+  if (recalctess && em) {
+    BKE_editmesh_tessface_calc(em);
+  }
 }
 
 /** \} */
@@ -117,163 +117,166 @@ void EDBM_redo_state_free(BMBackup *backup, BMEditMesh *em, int recalctess)
 
 bool EDBM_op_init(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *fmt, ...)
 {
-	BMesh *bm = em->bm;
-	va_list list;
+  BMesh *bm = em->bm;
+  va_list list;
 
-	va_start(list, fmt);
+  va_start(list, fmt);
 
-	if (!BMO_op_vinitf(bm, bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
-		BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
-		va_end(list);
-		return false;
-	}
+  if (!BMO_op_vinitf(bm, bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
+    BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
+    va_end(list);
+    return false;
+  }
 
-	if (!em->emcopy) {
-		em->emcopy = BKE_editmesh_copy(em);
-	}
-	em->emcopyusers++;
+  if (!em->emcopy) {
+    em->emcopy = BKE_editmesh_copy(em);
+  }
+  em->emcopyusers++;
 
-	va_end(list);
+  va_end(list);
 
-	return true;
+  return true;
 }
 
 /* returns 0 on error, 1 on success.  executes and finishes a bmesh operator */
 bool EDBM_op_finish(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const bool do_report)
 {
-	const char *errmsg;
-
-	BMO_op_finish(em->bm, bmop);
-
-	if (BMO_error_get(em->bm, &errmsg, NULL)) {
-		BMEditMesh *emcopy = em->emcopy;
-
-		if (do_report) {
-			BKE_report(op->reports, RPT_ERROR, errmsg);
-		}
-
-		EDBM_mesh_free(em);
-		*em = *emcopy;
-
-		MEM_freeN(emcopy);
-		em->emcopyusers = 0;
-		em->emcopy = NULL;
-
-		/* when copying, tessellation isn't to for faster copying,
-		 * but means we need to re-tessellate here */
-		if (em->looptris == NULL) {
-			BKE_editmesh_tessface_calc(em);
-		}
-
-		if (em->ob) {
-			DEG_id_tag_update(&((Mesh *)em->ob->data)->id, ID_RECALC_COPY_ON_WRITE);
-		}
-
-		return false;
-	}
-	else {
-		em->emcopyusers--;
-		if (em->emcopyusers < 0) {
-			printf("warning: em->emcopyusers was less than zero.\n");
-		}
-
-		if (em->emcopyusers <= 0) {
-			BKE_editmesh_free(em->emcopy);
-			MEM_freeN(em->emcopy);
-			em->emcopy = NULL;
-		}
-
-		return true;
-	}
+  const char *errmsg;
+
+  BMO_op_finish(em->bm, bmop);
+
+  if (BMO_error_get(em->bm, &errmsg, NULL)) {
+    BMEditMesh *emcopy = em->emcopy;
+
+    if (do_report) {
+      BKE_report(op->reports, RPT_ERROR, errmsg);
+    }
+
+    EDBM_mesh_free(em);
+    *em = *emcopy;
+
+    MEM_freeN(emcopy);
+    em->emcopyusers = 0;
+    em->emcopy = NULL;
+
+    /* when copying, tessellation isn't to for faster copying,
+     * but means we need to re-tessellate here */
+    if (em->looptris == NULL) {
+      BKE_editmesh_tessface_calc(em);
+    }
+
+    if (em->ob) {
+      DEG_id_tag_update(&((Mesh *)em->ob->data)->id, ID_RECALC_COPY_ON_WRITE);
+    }
+
+    return false;
+  }
+  else {
+    em->emcopyusers--;
+    if (em->emcopyusers < 0) {
+      printf("warning: em->emcopyusers was less than zero.\n");
+    }
+
+    if (em->emcopyusers <= 0) {
+      BKE_editmesh_free(em->emcopy);
+      MEM_freeN(em->emcopy);
+      em->emcopy = NULL;
+    }
+
+    return true;
+  }
 }
 
 bool EDBM_op_callf(BMEditMesh *em, wmOperator *op, const char *fmt, ...)
 {
-	BMesh *bm = em->bm;
-	BMOperator bmop;
-	va_list list;
+  BMesh *bm = em->bm;
+  BMOperator bmop;
+  va_list list;
 
-	va_start(list, fmt);
+  va_start(list, fmt);
 
-	if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
-		BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
-		va_end(list);
-		return false;
-	}
+  if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
+    BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
+    va_end(list);
+    return false;
+  }
 
-	if (!em->emcopy) {
-		em->emcopy = BKE_editmesh_copy(em);
-	}
-	em->emcopyusers++;
+  if (!em->emcopy) {
+    em->emcopy = BKE_editmesh_copy(em);
+  }
+  em->emcopyusers++;
 
-	BMO_op_exec(bm, &bmop);
+  BMO_op_exec(bm, &bmop);
 
-	va_end(list);
-	return EDBM_op_finish(em, &bmop, op, true);
+  va_end(list);
+  return EDBM_op_finish(em, &bmop, op, true);
 }
 
-bool EDBM_op_call_and_selectf(
-        BMEditMesh *em, wmOperator *op,
-        const char *select_slot_out, const bool select_extend,
-        const char *fmt, ...)
+bool EDBM_op_call_and_selectf(BMEditMesh *em,
+                              wmOperator *op,
+                              const char *select_slot_out,
+                              const bool select_extend,
+                              const char *fmt,
+                              ...)
 {
-	BMOpSlot *slot_select_out;
-	BMesh *bm = em->bm;
-	BMOperator bmop;
-	va_list list;
-	char hflag;
+  BMOpSlot *slot_select_out;
+  BMesh *bm = em->bm;
+  BMOperator bmop;
+  va_list list;
+  char hflag;
 
-	va_start(list, fmt);
+  va_start(list, fmt);
 
-	if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
-		BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
-		va_end(list);
-		return false;
-	}
+  if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
+    BKE_reportf(op->reports, RPT_ERROR, "Parse error in %s", __func__);
+    va_end(list);
+    return false;
+  }
 
-	if (!em->emcopy) {
-		em->emcopy = BKE_editmesh_copy(em);
-	}
-	em->emcopyusers++;
+  if (!em->emcopy) {
+    em->emcopy = BKE_editmesh_copy(em);
+  }
+  em->emcopyusers++;
 
-	BMO_op_exec(bm, &bmop);
+  BMO_op_exec(bm, &bmop);
 
-	slot_select_out = BMO_slot_get(bmop.slots_out, select_slot_out);
-	hflag = slot_select_out->slot_subtype.elem & BM_ALL_NOLOOP;
-	BLI_assert(hflag != 0);
+  slot_select_out = BMO_slot_get(bmop.slots_out, select_slot_out);
+  hflag = slot_select_out->slot_subtype.elem & BM_ALL_NOLOOP;
+  BLI_assert(hflag != 0);
 
-	if (select_extend == false) {
-		BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false);
-	}
+  if (select_extend == false) {
+    BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false);
+  }
 
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, select_slot_out, hflag, BM_ELEM_SELECT, true);
+  BMO_slot_buffer_hflag_enable(
+      em->bm, bmop.slots_out, select_slot_out, hflag, BM_ELEM_SELECT, true);
 
-	va_end(list);
-	return EDBM_op_finish(em, &bmop, op, true);
+  va_end(list);
+  return EDBM_op_finish(em, &bmop, op, true);
 }
 
 bool EDBM_op_call_silentf(BMEditMesh *em, const char *fmt, ...)
 {
-	BMesh *bm = em->bm;
-	BMOperator bmop;
-	va_list list;
+  BMesh *bm = em->bm;
+  BMOperator bmop;
+  va_list list;
 
-	va_start(list, fmt);
+  va_start(list, fmt);
 
-	if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
-		va_end(list);
-		return false;
-	}
+  if (!BMO_op_vinitf(bm, &bmop, BMO_FLAG_DEFAULTS, fmt, list)) {
+    va_end(list);
+    return false;
+  }
 
-	if (!em->emcopy) {
-		em->emcopy = BKE_editmesh_copy(em);
-	}
-	em->emcopyusers++;
+  if (!em->emcopy) {
+    em->emcopy = BKE_editmesh_copy(em);
+  }
+  em->emcopyusers++;
 
-	BMO_op_exec(bm, &bmop);
+  BMO_op_exec(bm, &bmop);
 
-	va_end(list);
-	return EDBM_op_finish(em, &bmop, NULL, false);
+  va_end(list);
+  return EDBM_op_finish(em, &bmop, NULL, false);
 }
 
 /** \} */
@@ -286,37 +289,40 @@ bool EDBM_op_call_silentf(BMEditMesh *em, const char *fmt, ...)
 
 void EDBM_mesh_make(Object *ob, const int select_mode, const bool add_key_index)
 {
-	Mesh *me = ob->data;
-	BMesh *bm;
-
-	if (UNLIKELY(!me->mpoly && me->totface)) {
-		BKE_mesh_convert_mfaces_to_mpolys(me);
-	}
-
-	bm = BKE_mesh_to_bmesh(
-	        me, ob, add_key_index,
-	        &((struct BMeshCreateParams){.use_toolflags = true,}));
-
-	if (me->edit_mesh) {
-		/* this happens when switching shape keys */
-		EDBM_mesh_free(me->edit_mesh);
-		MEM_freeN(me->edit_mesh);
-	}
-
-	/* currently executing operators re-tessellates, so we can avoid doing here
-	 * but at some point it may need to be added back. */
+  Mesh *me = ob->data;
+  BMesh *bm;
+
+  if (UNLIKELY(!me->mpoly && me->totface)) {
+    BKE_mesh_convert_mfaces_to_mpolys(me);
+  }
+
+  bm = BKE_mesh_to_bmesh(me,
+                         ob,
+                         add_key_index,
+                         &((struct BMeshCreateParams){
+                             .use_toolflags = true,
+                         }));
+
+  if (me->edit_mesh) {
+    /* this happens when switching shape keys */
+    EDBM_mesh_free(me->edit_mesh);
+    MEM_freeN(me->edit_mesh);
+  }
+
+  /* currently executing operators re-tessellates, so we can avoid doing here
+   * but at some point it may need to be added back. */
 #if 0
-	me->edit_mesh = BKE_editmesh_create(bm, true);
+  me->edit_mesh = BKE_editmesh_create(bm, true);
 #else
-	me->edit_mesh = BKE_editmesh_create(bm, false);
+  me->edit_mesh = BKE_editmesh_create(bm, false);
 #endif
 
-	me->edit_mesh->selectmode = me->edit_mesh->bm->selectmode = select_mode;
-	me->edit_mesh->mat_nr = (ob->actcol > 0) ? ob->actcol - 1 : 0;
-	me->edit_mesh->ob = ob;
+  me->edit_mesh->selectmode = me->edit_mesh->bm->selectmode = select_mode;
+  me->edit_mesh->mat_nr = (ob->actcol > 0) ? ob->actcol - 1 : 0;
+  me->edit_mesh->ob = ob;
 
-	/* we need to flush selection because the mode may have changed from when last in editmode */
-	EDBM_selectmode_flush(me->edit_mesh);
+  /* we need to flush selection because the mode may have changed from when last in editmode */
+  EDBM_selectmode_flush(me->edit_mesh);
 }
 
 /**
@@ -325,61 +331,63 @@ void EDBM_mesh_make(Object *ob, const int select_mode, const bool add_key_index)
  */
 void EDBM_mesh_load(Main *bmain, Object *ob)
 {
-	Mesh *me = ob->data;
-	BMesh *bm = me->edit_mesh->bm;
-
-	/* Workaround for T42360, 'ob->shapenr' should be 1 in this case.
-	 * however this isn't synchronized between objects at the moment. */
-	if (UNLIKELY((ob->shapenr == 0) && (me->key && !BLI_listbase_is_empty(&me->key->block)))) {
-		bm->shapenr = 1;
-	}
-
-	BM_mesh_bm_to_me(
-	        bmain, bm, me, (&(struct BMeshToMeshParams){
-	            .calc_object_remap = true,
-	        }));
+  Mesh *me = ob->data;
+  BMesh *bm = me->edit_mesh->bm;
+
+  /* Workaround for T42360, 'ob->shapenr' should be 1 in this case.
+   * however this isn't synchronized between objects at the moment. */
+  if (UNLIKELY((ob->shapenr == 0) && (me->key && !BLI_listbase_is_empty(&me->key->block)))) {
+    bm->shapenr = 1;
+  }
+
+  BM_mesh_bm_to_me(bmain,
+                   bm,
+                   me,
+                   (&(struct BMeshToMeshParams){
+                       .calc_object_remap = true,
+                   }));
 
 #ifdef USE_TESSFACE_DEFAULT
-	BKE_mesh_tessface_calc(me);
+  BKE_mesh_tessface_calc(me);
 #endif
 
-	/* Free derived mesh. usually this would happen through depsgraph but there
-	 * are exceptions like file save that will not cause this, and we want to
-	 * avoid ending up with an invalid derived mesh then.
-	 *
-	 * Do it for all objects which shares the same mesh datablock, since their
-	 * derived meshes might also be referencing data which was just freed,
-	 *
-	 * Annoying enough, but currently seems most efficient way to avoid access
-	 * of freed data on scene update, especially in cases when there are dependency
-	 * cycles.
-	 */
+  /* Free derived mesh. usually this would happen through depsgraph but there
+   * are exceptions like file save that will not cause this, and we want to
+   * avoid ending up with an invalid derived mesh then.
+   *
+   * Do it for all objects which shares the same mesh datablock, since their
+   * derived meshes might also be referencing data which was just freed,
+   *
+   * Annoying enough, but currently seems most efficient way to avoid access
+   * of freed data on scene update, especially in cases when there are dependency
+   * cycles.
+   */
 #if 0
-	for (Object *other_object = bmain->objects.first;
-	     other_object != NULL;
-	     other_object = other_object->id.next)
-	{
-		if (other_object->data == ob->data) {
-			BKE_object_free_derived_caches(other_object);
-		}
-	}
+  for (Object *other_object = bmain->objects.first;
+       other_object != NULL;
+       other_object = other_object->id.next)
+  {
+    if (other_object->data == ob->data) {
+      BKE_object_free_derived_caches(other_object);
+    }
+  }
 #endif
 }
 
 void EDBM_mesh_clear(BMEditMesh *em)
 {
-	/* clear bmesh */
-	BM_mesh_clear(em->bm);
-
-	/* free derived meshes */
-	BKE_editmesh_free_derivedmesh(em);
-
-	/* free tessellation data */
-	em->tottri = 0;
-	if (em->looptris) {
-		MEM_freeN(em->looptris);
-		em->looptris = NULL;
-	}
+  /* clear bmesh */
+  BM_mesh_clear(em->bm);
+
+  /* free derived meshes */
+  BKE_editmesh_free_derivedmesh(em);
+
+  /* free tessellation data */
+  em->tottri = 0;
+  if (em->looptris) {
+    MEM_freeN(em->looptris);
+    em->looptris = NULL;
+  }
 }
 
 /**
@@ -387,13 +395,13 @@ void EDBM_mesh_clear(BMEditMesh *em)
  */
 void EDBM_mesh_free(BMEditMesh *em)
 {
-	/* These tables aren't used yet, so it's not strictly necessary
-	 * to 'end' them (with 'e' param) but if someone tries to start
-	 * using them, having these in place will save a lot of pain */
-	ED_mesh_mirror_spatial_table(NULL, NULL, NULL, NULL, 'e');
-	ED_mesh_mirror_topo_table(NULL, NULL, 'e');
+  /* These tables aren't used yet, so it's not strictly necessary
+   * to 'end' them (with 'e' param) but if someone tries to start
+   * using them, having these in place will save a lot of pain */
+  ED_mesh_mirror_spatial_table(NULL, NULL, NULL, NULL, 'e');
+  ED_mesh_mirror_topo_table(NULL, NULL, 'e');
 
-	BKE_editmesh_free(em);
+  BKE_editmesh_free(em);
 }
 
 /** \} */
@@ -404,89 +412,99 @@ void EDBM_mesh_free(BMEditMesh *em)
 
 void EDBM_selectmode_to_scene(bContext *C)
 {
-	Scene *scene = CTX_data_scene(C);
-	Object *obedit = CTX_data_edit_object(C);
-	BMEditMesh *em = BKE_editmesh_from_object(obedit);
+  Scene *scene = CTX_data_scene(C);
+  Object *obedit = CTX_data_edit_object(C);
+  BMEditMesh *em = BKE_editmesh_from_object(obedit);
 
-	if (!em) {
-		return;
-	}
+  if (!em) {
+    return;
+  }
 
-	scene->toolsettings->selectmode = em->selectmode;
+  scene->toolsettings->selectmode = em->selectmode;
 
-	/* Request redraw of header buttons (to show new select mode) */
-	WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, scene);
+  /* Request redraw of header buttons (to show new select mode) */
+  WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, scene);
 }
 
 void EDBM_selectmode_flush_ex(BMEditMesh *em, const short selectmode)
 {
-	BM_mesh_select_mode_flush_ex(em->bm, selectmode);
+  BM_mesh_select_mode_flush_ex(em->bm, selectmode);
 }
 
 void EDBM_selectmode_flush(BMEditMesh *em)
 {
-	EDBM_selectmode_flush_ex(em, em->selectmode);
+  EDBM_selectmode_flush_ex(em, em->selectmode);
 }
 
 void EDBM_deselect_flush(BMEditMesh *em)
 {
-	/* function below doesn't use. just do this to keep the values in sync */
-	em->bm->selectmode = em->selectmode;
-	BM_mesh_deselect_flush(em->bm);
+  /* function below doesn't use. just do this to keep the values in sync */
+  em->bm->selectmode = em->selectmode;
+  BM_mesh_deselect_flush(em->bm);
 }
 
 void EDBM_select_flush(BMEditMesh *em)
 {
-	/* function below doesn't use. just do this to keep the values in sync */
-	em->bm->selectmode = em->selectmode;
-	BM_mesh_select_flush(em->bm);
+  /* function below doesn't use. just do this to keep the values in sync */
+  em->bm->selectmode = em->selectmode;
+  BM_mesh_select_flush(em->bm);
 }
 
 void EDBM_select_more(BMEditMesh *em, const bool use_face_step)
 {
-	BMOperator bmop;
-	const bool use_faces = (em->selectmode == SCE_SELECT_FACE);
-
-	BMO_op_initf(
-	        em->bm, &bmop, BMO_FLAG_DEFAULTS,
-	        "region_extend geom=%hvef use_contract=%b use_faces=%b use_face_step=%b",
-	        BM_ELEM_SELECT, false, use_faces, use_face_step);
-	BMO_op_exec(em->bm, &bmop);
-	/* don't flush selection in edge/vertex mode  */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, use_faces ? true : false);
-	BMO_op_finish(em->bm, &bmop);
-
-	EDBM_selectmode_flush(em);
+  BMOperator bmop;
+  const bool use_faces = (em->selectmode == SCE_SELECT_FACE);
+
+  BMO_op_initf(em->bm,
+               &bmop,
+               BMO_FLAG_DEFAULTS,
+               "region_extend geom=%hvef use_contract=%b use_faces=%b use_face_step=%b",
+               BM_ELEM_SELECT,
+               false,
+               use_faces,
+               use_face_step);
+  BMO_op_exec(em->bm, &bmop);
+  /* don't flush selection in edge/vertex mode  */
+  BMO_slot_buffer_hflag_enable(
+      em->bm, bmop.slots_out, "geom.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, use_faces ? true : false);
+  BMO_op_finish(em->bm, &bmop);
+
+  EDBM_selectmode_flush(em);
 }
 
 void EDBM_select_less(BMEditMesh *em, const bool use_face_step)
 {
-	BMOperator bmop;
-	const bool use_faces = (em->selectmode == SCE_SELECT_FACE);
-
-	BMO_op_initf(
-	        em->bm, &bmop, BMO_FLAG_DEFAULTS,
-	        "region_extend geom=%hvef use_contract=%b use_faces=%b use_face_step=%b",
-	        BM_ELEM_SELECT, true, use_faces, use_face_step);
-	BMO_op_exec(em->bm, &bmop);
-	/* don't flush selection in edge/vertex mode  */
-	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "geom.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, use_faces ? true : false);
-	BMO_op_finish(em->bm, &bmop);
-
-	EDBM_selectmode_flush(em);
-
-	/* only needed for select less, ensure we don't have isolated elements remaining */
-	BM_mesh_select_mode_clean(em->bm);
+  BMOperator bmop;
+  const bool use_faces = (em->selectmode == SCE_SELECT_FACE);
+
+  BMO_op_initf(em->bm,
+               &bmop,
+               BMO_FLAG_DEFAULTS,
+               "region_extend geom=%hvef use_contract=%b use_faces=%b use_face_step=%b",
+               BM_ELEM_SELECT,
+               true,
+               use_faces,
+               use_face_step);
+  BMO_op_exec(em->bm, &bmop);
+  /* don't flush selection in edge/vertex mode  */
+  BMO_slot_buffer_hflag_disable(
+      em->bm, bmop.slots_out, "geom.out", BM_ALL_NOLOOP, BM_ELEM_SELECT, use_faces ? true : false);
+  BMO_op_finish(em->bm, &bmop);
+
+  EDBM_selectmode_flush(em);
+
+  /* only needed for select less, ensure we don't have isolated elements remaining */
+  BM_mesh_select_mode_clean(em->bm);
 }
 
 void EDBM_flag_disable_all(BMEditMesh *em, const char hflag)
 {
-	BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, false);
+  BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, false);
 }
 
 void EDBM_flag_enable_all(BMEditMesh *em, const char hflag)
 {
-	BM_mesh_elem_hflag_enable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, true);
+  BM_mesh_elem_hflag_enable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, true);
 }
 
 /** \} */
@@ -498,419 +516,431 @@ void EDBM_flag_enable_all(BMEditMesh *em, const char hflag)
 /**
  * Return a new UVVertMap from the editmesh
  */
-UvVertMap *BM_uv_vert_map_create(
-        BMesh *bm,
-        const float limit[2], const bool use_select, const bool use_winding)
+UvVertMap *BM_uv_vert_map_create(BMesh *bm,
+                                 const float limit[2],
+                                 const bool use_select,
+                                 const bool use_winding)
 {
-	BMVert *ev;
-	BMFace *efa;
-	BMLoop *l;
-	BMIter iter, liter;
-	/* vars from original func */
-	UvVertMap *vmap;
-	UvMapVert *buf;
-	MLoopUV *luv;
-	unsigned int a;
-	int totverts, i, totuv, totfaces;
-	const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
-	bool *winding = NULL;
-	BLI_buffer_declare_static(vec2f, tf_uv_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE);
-
-	BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
-
-	totfaces = bm->totface;
-	totverts = bm->totvert;
-	totuv = 0;
-
-	/* generate UvMapVert array */
-	BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
-		if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
-			totuv += efa->len;
-		}
-	}
-
-	if (totuv == 0) {
-		return NULL;
-	}
-	vmap = (UvVertMap *)MEM_callocN(sizeof(*vmap), "UvVertMap");
-	if (!vmap) {
-		return NULL;
-	}
-
-	vmap->vert = (UvMapVert **)MEM_callocN(sizeof(*vmap->vert) * totverts, "UvMapVert_pt");
-	buf = vmap->buf = (UvMapVert *)MEM_callocN(sizeof(*vmap->buf) * totuv, "UvMapVert");
-	if (use_winding) {
-		winding = MEM_callocN(sizeof(*winding) * totfaces, "winding");
-	}
-
-	if (!vmap->vert || !vmap->buf) {
-		BKE_mesh_uv_vert_map_free(vmap);
-		return NULL;
-	}
-
-	BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, a) {
-		if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
-			float (*tf_uv)[2] = NULL;
-
-			if (use_winding) {
-				tf_uv = (float (*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, efa->len);
-			}
-
-			BM_ITER_ELEM_INDEX(l, &liter, efa, BM_LOOPS_OF_FACE, i) {
-				buf->loop_of_poly_index = i;
-				buf->poly_index = a;
-				buf->separate = 0;
-
-				buf->next = vmap->vert[BM_elem_index_get(l->v)];
-				vmap->vert[BM_elem_index_get(l->v)] = buf;
-				buf++;
-
-				if (use_winding) {
-					luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-					copy_v2_v2(tf_uv[i], luv->uv);
-				}
-			}
-
-			if (use_winding) {
-				winding[a] = cross_poly_v2(tf_uv, efa->len) > 0;
-			}
-		}
-	}
-
-	/* sort individual uvs for each vert */
-	BM_ITER_MESH_INDEX (ev, &iter, bm, BM_VERTS_OF_MESH, a) {
-		UvMapVert *newvlist = NULL, *vlist = vmap->vert[a];
-		UvMapVert *iterv, *v, *lastv, *next;
-		float *uv, *uv2, uvdiff[2];
-
-		while (vlist) {
-			v = vlist;
-			vlist = vlist->next;
-			v->next = newvlist;
-			newvlist = v;
-
-			efa = BM_face_at_index(bm, v->poly_index);
-
-			l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, v->loop_of_poly_index);
-			luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-			uv = luv->uv;
-
-			lastv = NULL;
-			iterv = vlist;
-
-			while (iterv) {
-				next = iterv->next;
-				efa = BM_face_at_index(bm, iterv->poly_index);
-				l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, iterv->loop_of_poly_index);
-				luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-				uv2 = luv->uv;
-
-				sub_v2_v2v2(uvdiff, uv2, uv);
-
-				if (fabsf(uvdiff[0]) < limit[0] && fabsf(uvdiff[1]) < limit[1] &&
-				    (!use_winding || winding[iterv->poly_index] == winding[v->poly_index]))
-				{
-					if (lastv) lastv->next = next;
-					else vlist = next;
-					iterv->next = newvlist;
-					newvlist = iterv;
-				}
-				else {
-					lastv = iterv;
-				}
-
-				iterv = next;
-			}
-
-			newvlist->separate = 1;
-		}
-
-		vmap->vert[a] = newvlist;
-	}
-
-	if (use_winding) {
-		MEM_freeN(winding);
-	}
-
-	BLI_buffer_free(&tf_uv_buf);
-
-	return vmap;
+  BMVert *ev;
+  BMFace *efa;
+  BMLoop *l;
+  BMIter iter, liter;
+  /* vars from original func */
+  UvVertMap *vmap;
+  UvMapVert *buf;
+  MLoopUV *luv;
+  unsigned int a;
+  int totverts, i, totuv, totfaces;
+  const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
+  bool *winding = NULL;
+  BLI_buffer_declare_static(vec2f, tf_uv_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE);
+
+  BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
+
+  totfaces = bm->totface;
+  totverts = bm->totvert;
+  totuv = 0;
+
+  /* generate UvMapVert array */
+  BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
+    if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
+      totuv += efa->len;
+    }
+  }
+
+  if (totuv == 0) {
+    return NULL;
+  }
+  vmap = (UvVertMap *)MEM_callocN(sizeof(*vmap), "UvVertMap");
+  if (!vmap) {
+    return NULL;
+  }
+
+  vmap->vert = (UvMapVert **)MEM_callocN(sizeof(*vmap->vert) * totverts, "UvMapVert_pt");
+  buf = vmap->buf = (UvMapVert *)MEM_callocN(sizeof(*vmap->buf) * totuv, "UvMapVert");
+  if (use_winding) {
+    winding = MEM_callocN(sizeof(*winding) * totfaces, "winding");
+  }
+
+  if (!vmap->vert || !vmap->buf) {
+    BKE_mesh_uv_vert_map_free(vmap);
+    return NULL;
+  }
+
+  BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, a) {
+    if ((use_select == false) || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
+      float(*tf_uv)[2] = NULL;
+
+      if (use_winding) {
+        tf_uv = (float(*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, efa->len);
+      }
+
+      BM_ITER_ELEM_INDEX(l, &liter, efa, BM_LOOPS_OF_FACE, i)
+      {
+        buf->loop_of_poly_index = i;
+        buf->poly_index = a;
+        buf->separate = 0;
+
+        buf->next = vmap->vert[BM_elem_index_get(l->v)];
+        vmap->vert[BM_elem_index_get(l->v)] = buf;
+        buf++;
+
+        if (use_winding) {
+          luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+          copy_v2_v2(tf_uv[i], luv->uv);
+        }
+      }
+
+      if (use_winding) {
+        winding[a] = cross_poly_v2(tf_uv, efa->len) > 0;
+      }
+    }
+  }
+
+  /* sort individual uvs for each vert */
+  BM_ITER_MESH_INDEX (ev, &iter, bm, BM_VERTS_OF_MESH, a) {
+    UvMapVert *newvlist = NULL, *vlist = vmap->vert[a];
+    UvMapVert *iterv, *v, *lastv, *next;
+    float *uv, *uv2, uvdiff[2];
+
+    while (vlist) {
+      v = vlist;
+      vlist = vlist->next;
+      v->next = newvlist;
+      newvlist = v;
+
+      efa = BM_face_at_index(bm, v->poly_index);
+
+      l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, v->loop_of_poly_index);
+      luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+      uv = luv->uv;
+
+      lastv = NULL;
+      iterv = vlist;
+
+      while (iterv) {
+        next = iterv->next;
+        efa = BM_face_at_index(bm, iterv->poly_index);
+        l = BM_iter_at_index(bm, BM_LOOPS_OF_FACE, efa, iterv->loop_of_poly_index);
+        luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+        uv2 = luv->uv;
+
+        sub_v2_v2v2(uvdiff, uv2, uv);
+
+        if (fabsf(uvdiff[0]) < limit[0] && fabsf(uvdiff[1]) < limit[1] &&
+            (!use_winding || winding[iterv->poly_index] == winding[v->poly_index])) {
+          if (lastv)
+            lastv->next = next;
+          else
+            vlist = next;
+          iterv->next = newvlist;
+          newvlist = iterv;
+        }
+        else {
+          lastv = iterv;
+        }
+
+        iterv = next;
+      }
+
+      newvlist->separate = 1;
+    }
+
+    vmap->vert[a] = newvlist;
+  }
+
+  if (use_winding) {
+    MEM_freeN(winding);
+  }
+
+  BLI_buffer_free(&tf_uv_buf);
+
+  return vmap;
 }
 
 UvMapVert *BM_uv_vert_map_at_index(UvVertMap *vmap, unsigned int v)
 {
-	return vmap->vert[v];
+  return vmap->vert[v];
 }
 
 /* A specialized vert map used by stitch operator */
-UvElementMap *BM_uv_element_map_create(
-        BMesh *bm,
-        const bool selected, const bool use_winding, const bool do_islands)
+UvElementMap *BM_uv_element_map_create(BMesh *bm,
+                                       const bool selected,
+                                       const bool use_winding,
+                                       const bool do_islands)
 {
-	BMVert *ev;
-	BMFace *efa;
-	BMLoop *l;
-	BMIter iter, liter;
-	/* vars from original func */
-	UvElementMap *element_map;
-	UvElement *buf;
-	bool *winding = NULL;
-	BLI_buffer_declare_static(vec2f, tf_uv_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE);
-
-	MLoopUV *luv;
-	int totverts, totfaces, i, totuv, j;
-
-	const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
-
-	BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
-
-	totfaces = bm->totface;
-	totverts = bm->totvert;
-	totuv = 0;
-
-	/* generate UvElement array */
-	BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
-		if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
-			totuv += efa->len;
-		}
-	}
-
-	if (totuv == 0) {
-		return NULL;
-	}
-
-	element_map = (UvElementMap *)MEM_callocN(sizeof(*element_map), "UvElementMap");
-	element_map->totalUVs = totuv;
-	element_map->vert = (UvElement **)MEM_callocN(sizeof(*element_map->vert) * totverts, "UvElementVerts");
-	buf = element_map->buf = (UvElement *)MEM_callocN(sizeof(*element_map->buf) * totuv, "UvElement");
-
-	if (use_winding) {
-		winding = MEM_mallocN(sizeof(*winding) * totfaces, "winding");
-	}
-
-	BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, j) {
-
-		if (use_winding) {
-			winding[j] = false;
-		}
-
-		if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
-			float (*tf_uv)[2] = NULL;
-
-			if (use_winding) {
-				tf_uv = (float (*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, efa->len);
-			}
-
-			BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
-				buf->l = l;
-				buf->separate = 0;
-				buf->island = INVALID_ISLAND;
-				buf->loop_of_poly_index = i;
-
-				buf->next = element_map->vert[BM_elem_index_get(l->v)];
-				element_map->vert[BM_elem_index_get(l->v)] = buf;
-
-				if (use_winding) {
-					luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-					copy_v2_v2(tf_uv[i], luv->uv);
-				}
-
-				buf++;
-			}
-
-			if (use_winding) {
-				winding[j] = cross_poly_v2(tf_uv, efa->len) > 0;
-			}
-		}
-	}
-
-	/* sort individual uvs for each vert */
-	BM_ITER_MESH_INDEX (ev, &iter, bm, BM_VERTS_OF_MESH, i) {
-		UvElement *newvlist = NULL, *vlist = element_map->vert[i];
-		UvElement *iterv, *v, *lastv, *next;
-		float *uv, *uv2, uvdiff[2];
-
-		while (vlist) {
-			v = vlist;
-			vlist = vlist->next;
-			v->next = newvlist;
-			newvlist = v;
-
-			l = v->l;
-			luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-			uv = luv->uv;
-
-			lastv = NULL;
-			iterv = vlist;
-
-			while (iterv) {
-				next = iterv->next;
-
-				l = iterv->l;
-				luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-				uv2 = luv->uv;
-
-				sub_v2_v2v2(uvdiff, uv2, uv);
-
-				if (fabsf(uvdiff[0]) < STD_UV_CONNECT_LIMIT && fabsf(uvdiff[1]) < STD_UV_CONNECT_LIMIT &&
-				    (!use_winding || winding[BM_elem_index_get(iterv->l->f)] == winding[BM_elem_index_get(v->l->f)]))
-				{
-					if (lastv) lastv->next = next;
-					else vlist = next;
-					iterv->next = newvlist;
-					newvlist = iterv;
-				}
-				else {
-					lastv = iterv;
-				}
-
-				iterv = next;
-			}
-
-			newvlist->separate = 1;
-		}
-
-		element_map->vert[i] = newvlist;
-	}
-
-	if (use_winding) {
-		MEM_freeN(winding);
-	}
-
-	if (do_islands) {
-		unsigned int *map;
-		BMFace **stack;
-		int stacksize = 0;
-		UvElement *islandbuf;
-		/* island number for faces */
-		int *island_number = NULL;
-
-		int nislands = 0, islandbufsize = 0;
-
-		/* map holds the map from current vmap->buf to the new, sorted map */
-		map = MEM_mallocN(sizeof(*map) * totuv, "uvelement_remap");
-		stack = MEM_mallocN(sizeof(*stack) * bm->totface, "uv_island_face_stack");
-		islandbuf = MEM_callocN(sizeof(*islandbuf) * totuv, "uvelement_island_buffer");
-		island_number = MEM_mallocN(sizeof(*island_number) * totfaces, "uv_island_number_face");
-		copy_vn_i(island_number, totfaces, INVALID_ISLAND);
-
-		/* at this point, every UvElement in vert points to a UvElement sharing the same vertex.
-		 * Now we should sort uv's in islands. */
-		for (i = 0; i < totuv; i++) {
-			if (element_map->buf[i].island == INVALID_ISLAND) {
-				element_map->buf[i].island = nislands;
-				stack[0] = element_map->buf[i].l->f;
-				island_number[BM_elem_index_get(stack[0])] = nislands;
-				stacksize = 1;
-
-				while (stacksize > 0) {
-					efa = stack[--stacksize];
-
-					BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
-						UvElement *element, *initelement = element_map->vert[BM_elem_index_get(l->v)];
-
-						for (element = initelement; element; element = element->next) {
-							if (element->separate)
-								initelement = element;
-
-							if (element->l->f == efa) {
-								/* found the uv corresponding to our face and vertex.
-								 * Now fill it to the buffer */
-								element->island = nislands;
-								map[element - element_map->buf] = islandbufsize;
-								islandbuf[islandbufsize].l = element->l;
-								islandbuf[islandbufsize].separate = element->separate;
-								islandbuf[islandbufsize].loop_of_poly_index = element->loop_of_poly_index;
-								islandbuf[islandbufsize].island =  nislands;
-								islandbufsize++;
-
-								for (element = initelement; element; element = element->next) {
-									if (element->separate && element != initelement)
-										break;
-
-									if (island_number[BM_elem_index_get(element->l->f)] == INVALID_ISLAND) {
-										stack[stacksize++] = element->l->f;
-										island_number[BM_elem_index_get(element->l->f)] = nislands;
-									}
-								}
-								break;
-							}
-						}
-					}
-				}
-
-				nislands++;
-			}
-		}
-
-		MEM_freeN(island_number);
-
-		/* remap */
-		for (i = 0; i < bm->totvert; i++) {
-			/* important since we may do selection only. Some of these may be NULL */
-			if (element_map->vert[i])
-				element_map->vert[i] = &islandbuf[map[element_map->vert[i] - element_map->buf]];
-		}
-
-		element_map->islandIndices = MEM_callocN(sizeof(*element_map->islandIndices) * nislands, "UvElementMap_island_indices");
-		j = 0;
-		for (i = 0; i < totuv; i++) {
-			UvElement *element = element_map->buf[i].next;
-			if (element == NULL)
-				islandbuf[map[i]].next = NULL;
-			else
-				islandbuf[map[i]].next = &islandbuf[map[element - element_map->buf]];
-
-			if (islandbuf[i].island != j) {
-				j++;
-				element_map->islandIndices[j] = i;
-			}
-		}
-
-		MEM_freeN(element_map->buf);
-
-		element_map->buf = islandbuf;
-		element_map->totalIslands = nislands;
-		MEM_freeN(stack);
-		MEM_freeN(map);
-	}
-
-	BLI_buffer_free(&tf_uv_buf);
-
-	return element_map;
+  BMVert *ev;
+  BMFace *efa;
+  BMLoop *l;
+  BMIter iter, liter;
+  /* vars from original func */
+  UvElementMap *element_map;
+  UvElement *buf;
+  bool *winding = NULL;
+  BLI_buffer_declare_static(vec2f, tf_uv_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE);
+
+  MLoopUV *luv;
+  int totverts, totfaces, i, totuv, j;
+
+  const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
+
+  BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
+
+  totfaces = bm->totface;
+  totverts = bm->totvert;
+  totuv = 0;
+
+  /* generate UvElement array */
+  BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
+    if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
+      totuv += efa->len;
+    }
+  }
+
+  if (totuv == 0) {
+    return NULL;
+  }
+
+  element_map = (UvElementMap *)MEM_callocN(sizeof(*element_map), "UvElementMap");
+  element_map->totalUVs = totuv;
+  element_map->vert = (UvElement **)MEM_callocN(sizeof(*element_map->vert) * totverts,
+                                                "UvElementVerts");
+  buf = element_map->buf = (UvElement *)MEM_callocN(sizeof(*element_map->buf) * totuv,
+                                                    "UvElement");
+
+  if (use_winding) {
+    winding = MEM_mallocN(sizeof(*winding) * totfaces, "winding");
+  }
+
+  BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, j) {
+
+    if (use_winding) {
+      winding[j] = false;
+    }
+
+    if (!selected || BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
+      float(*tf_uv)[2] = NULL;
+
+      if (use_winding) {
+        tf_uv = (float(*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, efa->len);
+      }
+
+      BM_ITER_ELEM_INDEX(l, &liter, efa, BM_LOOPS_OF_FACE, i)
+      {
+        buf->l = l;
+        buf->separate = 0;
+        buf->island = INVALID_ISLAND;
+        buf->loop_of_poly_index = i;
+
+        buf->next = element_map->vert[BM_elem_index_get(l->v)];
+        element_map->vert[BM_elem_index_get(l->v)] = buf;
+
+        if (use_winding) {
+          luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+          copy_v2_v2(tf_uv[i], luv->uv);
+        }
+
+        buf++;
+      }
+
+      if (use_winding) {
+        winding[j] = cross_poly_v2(tf_uv, efa->len) > 0;
+      }
+    }
+  }
+
+  /* sort individual uvs for each vert */
+  BM_ITER_MESH_INDEX (ev, &iter, bm, BM_VERTS_OF_MESH, i) {
+    UvElement *newvlist = NULL, *vlist = element_map->vert[i];
+    UvElement *iterv, *v, *lastv, *next;
+    float *uv, *uv2, uvdiff[2];
+
+    while (vlist) {
+      v = vlist;
+      vlist = vlist->next;
+      v->next = newvlist;
+      newvlist = v;
+
+      l = v->l;
+      luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+      uv = luv->uv;
+
+      lastv = NULL;
+      iterv = vlist;
+
+      while (iterv) {
+        next = iterv->next;
+
+        l = iterv->l;
+        luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
+        uv2 = luv->uv;
+
+        sub_v2_v2v2(uvdiff, uv2, uv);
+
+        if (fabsf(uvdiff[0]) < STD_UV_CONNECT_LIMIT && fabsf(uvdiff[1]) < STD_UV_CONNECT_LIMIT &&
+            (!use_winding ||
+             winding[BM_elem_index_get(iterv->l->f)] == winding[BM_elem_index_get(v->l->f)])) {
+          if (lastv)
+            lastv->next = next;
+          else
+            vlist = next;
+          iterv->next = newvlist;
+          newvlist = iterv;
+        }
+        else {
+          lastv = iterv;
+        }
+
+        iterv = next;
+      }
+
+      newvlist->separate = 1;
+    }
+
+    element_map->vert[i] = newvlist;
+  }
+
+  if (use_winding) {
+    MEM_freeN(winding);
+  }
+
+  if (do_islands) {
+    unsigned int *map;
+    BMFace **stack;
+    int stacksize = 0;
+    UvElement *islandbuf;
+    /* island number for faces */
+    int *island_number = NULL;
+
+    int nislands = 0, islandbufsize = 0;
+
+    /* map holds the map from current vmap->buf to the new, sorted map */
+    map = MEM_mallocN(sizeof(*map) * totuv, "uvelement_remap");
+    stack = MEM_mallocN(sizeof(*stack) * bm->totface, "uv_island_face_stack");
+    islandbuf = MEM_callocN(sizeof(*islandbuf) * totuv, "uvelement_island_buffer");
+    island_number = MEM_mallocN(sizeof(*island_number) * totfaces, "uv_island_number_face");
+    copy_vn_i(island_number, totfaces, INVALID_ISLAND);
+
+    /* at this point, every UvElement in vert points to a UvElement sharing the same vertex.
+     * Now we should sort uv's in islands. */
+    for (i = 0; i < totuv; i++) {
+      if (element_map->buf[i].island == INVALID_ISLAND) {
+        element_map->buf[i].island = nislands;
+        stack[0] = element_map->buf[i].l->f;
+        island_number[BM_elem_index_get(stack[0])] = nislands;
+        stacksize = 1;
+
+        while (stacksize > 0) {
+          efa = stack[--stacksize];
+
+          BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
+            UvElement *element, *initelement = element_map->vert[BM_elem_index_get(l->v)];
+
+            for (element = initelement; element; element = element->next) {
+              if (element->separate)
+                initelement = element;
+
+              if (element->l->f == efa) {
+                /* found the uv corresponding to our face and vertex.
+                 * Now fill it to the buffer */
+                element->island = nislands;
+                map[element - element_map->buf] = islandbufsize;
+                islandbuf[islandbufsize].l = element->l;
+                islandbuf[islandbufsize].separate = element->separate;
+                islandbuf[islandbufsize].loop_of_poly_index = element->loop_of_poly_index;
+                islandbuf[islandbufsize].island = nislands;
+                islandbufsize++;
+
+                for (element = initelement; element; element = element->next) {
+                  if (element->separate && element != initelement)
+                    break;
+
+                  if (island_number[BM_elem_index_get(element->l->f)] == INVALID_ISLAND) {
+                    stack[stacksize++] = element->l->f;
+                    island_number[BM_elem_index_get(element->l->f)] = nislands;
+                  }
+                }
+                break;
+              }
+            }
+          }
+        }
+
+        nislands++;
+      }
+    }
+
+    MEM_freeN(island_number);
+
+    /* remap */
+    for (i = 0; i < bm->totvert; i++) {
+      /* important since we may do selection only. Some of these may be NULL */
+      if (element_map->vert[i])
+        element_map->vert[i] = &islandbuf[map[element_map->vert[i] - element_map->buf]];
+    }
+
+    element_map->islandIndices = MEM_callocN(sizeof(*element_map->islandIndices) * nislands,
+                                             "UvElementMap_island_indices");
+    j = 0;
+    for (i = 0; i < totuv; i++) {
+      UvElement *element = element_map->buf[i].next;
+      if (element == NULL)
+        islandbuf[map[i]].next = NULL;
+      else
+        islandbuf[map[i]].next = &islandbuf[map[element - element_map->buf]];
+
+      if (islandbuf[i].island != j) {
+        j++;
+        element_map->islandIndices[j] = i;
+      }
+    }
+
+    MEM_freeN(element_map->buf);
+
+    element_map->buf = islandbuf;
+    element_map->totalIslands = nislands;
+    MEM_freeN(stack);
+    MEM_freeN(map);
+  }
+
+  BLI_buffer_free(&tf_uv_buf);
+
+  return element_map;
 }
 
 void BM_uv_vert_map_free(UvVertMap *vmap)
 {
-	if (vmap) {
-		if (vmap->vert) MEM_freeN(vmap->vert);
-		if (vmap->buf) MEM_freeN(vmap->buf);
-		MEM_freeN(vmap);
-	}
+  if (vmap) {
+    if (vmap->vert)
+      MEM_freeN(vmap->vert);
+    if (vmap->buf)
+      MEM_freeN(vmap->buf);
+    MEM_freeN(vmap);
+  }
 }
 
 void BM_uv_element_map_free(UvElementMap *element_map)
 {
-	if (element_map) {
-		if (element_map->vert) MEM_freeN(element_map->vert);
-		if (element_map->buf) MEM_freeN(element_map->buf);
-		if (element_map->islandIndices) MEM_freeN(element_map->islandIndices);
-		MEM_freeN(element_map);
-	}
+  if (element_map) {
+    if (element_map->vert)
+      MEM_freeN(element_map->vert);
+    if (element_map->buf)
+      MEM_freeN(element_map->buf);
+    if (element_map->islandIndices)
+      MEM_freeN(element_map->islandIndices);
+    MEM_freeN(element_map);
+  }
 }
 
 UvElement *BM_uv_element_get(UvElementMap *map, BMFace *efa, BMLoop *l)
 {
-	for (UvElement *element = map->vert[BM_elem_index_get(l->v)];
-	     element;
-	     element = element->next)
-	{
-		if (element->l->f == efa) {
-			return element;
-		}
-	}
-
-	return NULL;
+  for (UvElement *element = map->vert[BM_elem_index_get(l->v)]; element; element = element->next) {
+    if (element->l->f == efa) {
+      return element;
+    }
+  }
+
+  return NULL;
 }
 
 /** \} */
@@ -925,33 +955,32 @@ UvElement *BM_uv_element_get(UvElementMap *map, BMFace *efa, BMLoop *l)
  */
 BMFace *EDBM_uv_active_face_get(BMEditMesh *em, const bool sloppy, const bool selected)
 {
-	BMFace *efa = NULL;
+  BMFace *efa = NULL;
 
-	if (!EDBM_uv_check(em)) {
-		return NULL;
-	}
+  if (!EDBM_uv_check(em)) {
+    return NULL;
+  }
 
-	efa = BM_mesh_active_face_get(em->bm, sloppy, selected);
+  efa = BM_mesh_active_face_get(em->bm, sloppy, selected);
 
-	if (efa) {
-		return efa;
-	}
+  if (efa) {
+    return efa;
+  }
 
-	return NULL;
+  return NULL;
 }
 
 /* can we edit UV's for this mesh?*/
 bool EDBM_uv_check(BMEditMesh *em)
 {
-	/* some of these checks could be a touch overkill */
-	return em && em->bm->totface &&
-	       CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV);
+  /* some of these checks could be a touch overkill */
+  return em && em->bm->totface && CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV);
 }
 
 bool EDBM_vert_color_check(BMEditMesh *em)
 {
-	/* some of these checks could be a touch overkill */
-	return em && em->bm->totface && CustomData_has_layer(&em->bm->ldata, CD_MLOOPCOL);
+  /* some of these checks could be a touch overkill */
+  return em && em->bm->totface && CustomData_has_layer(&em->bm->ldata, CD_MLOOPCOL);
 }
 
 /** \} */
@@ -962,8 +991,8 @@ bool EDBM_vert_color_check(BMEditMesh *em)
 
 static BMVert *cache_mirr_intptr_as_bmvert(intptr_t *index_lookup, int index)
 {
-	intptr_t eve_i = index_lookup[index];
-	return (eve_i == -1) ? NULL : (BMVert *)eve_i;
+  intptr_t eve_i = index_lookup[index];
+  return (eve_i == -1) ? NULL : (BMVert *)eve_i;
 }
 
 /**
@@ -994,203 +1023,212 @@ static BMVert *cache_mirr_intptr_as_bmvert(intptr_t *index_lookup, int index)
  * \param maxdist: Distance for close point test.
  * \param r_index: Optional array to write into, as an alternative to a customdata layer (length of total verts).
  */
-void EDBM_verts_mirror_cache_begin_ex(
-        BMEditMesh *em, const int axis, const bool use_self, const bool use_select,
-        /* extra args */
-        const bool use_topology, float maxdist, int *r_index)
+void EDBM_verts_mirror_cache_begin_ex(BMEditMesh *em,
+                                      const int axis,
+                                      const bool use_self,
+                                      const bool use_select,
+                                      /* extra args */
+                                      const bool use_topology,
+                                      float maxdist,
+                                      int *r_index)
 {
-	Mesh *me = (Mesh *)em->ob->data;
-	BMesh *bm = em->bm;
-	BMIter iter;
-	BMVert *v;
-	int cd_vmirr_offset = 0;
-	int i;
-	const float maxdist_sq = SQUARE(maxdist);
-
-	/* one or the other is used depending if topo is enabled */
-	KDTree_3d *tree = NULL;
-	MirrTopoStore_t mesh_topo_store = {NULL, -1, -1, -1};
-
-	BM_mesh_elem_table_ensure(bm, BM_VERT);
-
-	if (r_index == NULL) {
-		const char *layer_id = BM_CD_LAYER_ID;
-		em->mirror_cdlayer = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, layer_id);
-		if (em->mirror_cdlayer == -1) {
-			BM_data_layer_add_named(bm, &bm->vdata, CD_PROP_INT, layer_id);
-			em->mirror_cdlayer = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, layer_id);
-		}
-
-		cd_vmirr_offset = CustomData_get_n_offset(
-		        &bm->vdata, CD_PROP_INT,
-		        em->mirror_cdlayer - CustomData_get_layer_index(&bm->vdata, CD_PROP_INT));
-
-		bm->vdata.layers[em->mirror_cdlayer].flag |= CD_FLAG_TEMPORARY;
-	}
-
-	BM_mesh_elem_index_ensure(bm, BM_VERT);
-
-	if (use_topology) {
-		ED_mesh_mirrtopo_init(me, NULL, &mesh_topo_store, true);
-	}
-	else {
-		tree = BLI_kdtree_3d_new(bm->totvert);
-		BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
-			BLI_kdtree_3d_insert(tree, i, v->co);
-		}
-		BLI_kdtree_3d_balance(tree);
-	}
+  Mesh *me = (Mesh *)em->ob->data;
+  BMesh *bm = em->bm;
+  BMIter iter;
+  BMVert *v;
+  int cd_vmirr_offset = 0;
+  int i;
+  const float maxdist_sq = SQUARE(maxdist);
+
+  /* one or the other is used depending if topo is enabled */
+  KDTree_3d *tree = NULL;
+  MirrTopoStore_t mesh_topo_store = {NULL, -1, -1, -1};
+
+  BM_mesh_elem_table_ensure(bm, BM_VERT);
+
+  if (r_index == NULL) {
+    const char *layer_id = BM_CD_LAYER_ID;
+    em->mirror_cdlayer = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, layer_id);
+    if (em->mirror_cdlayer == -1) {
+      BM_data_layer_add_named(bm, &bm->vdata, CD_PROP_INT, layer_id);
+      em->mirror_cdlayer = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, layer_id);
+    }
+
+    cd_vmirr_offset = CustomData_get_n_offset(
+        &bm->vdata,
+        CD_PROP_INT,
+        em->mirror_cdlayer - CustomData_get_layer_index(&bm->vdata, CD_PROP_INT));
+
+    bm->vdata.layers[em->mirror_cdlayer].flag |= CD_FLAG_TEMPORARY;
+  }
+
+  BM_mesh_elem_index_ensure(bm, BM_VERT);
+
+  if (use_topology) {
+    ED_mesh_mirrtopo_init(me, NULL, &mesh_topo_store, true);
+  }
+  else {
+    tree = BLI_kdtree_3d_new(bm->totvert);
+    BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
+      BLI_kdtree_3d_insert(tree, i, v->co);
+    }
+    BLI_kdtree_3d_balance(tree);
+  }
 
 #define VERT_INTPTR(_v, _i) (r_index ? &r_index[_i] : BM_ELEM_CD_GET_VOID_P(_v, cd_vmirr_offset))
 
-	BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
-		BLI_assert(BM_elem_index_get(v) == i);
-
-		/* temporary for testing, check for selection */
-		if (use_select && !BM_elem_flag_test(v, BM_ELEM_SELECT)) {
-			/* do nothing */
-		}
-		else {
-			BMVert *v_mirr;
-			int *idx = VERT_INTPTR(v, i);
-
-			if (use_topology) {
-				v_mirr = cache_mirr_intptr_as_bmvert(mesh_topo_store.index_lookup, i);
-			}
-			else {
-				int i_mirr;
-				float co[3];
-				copy_v3_v3(co, v->co);
-				co[axis] *= -1.0f;
-
-				v_mirr = NULL;
-				i_mirr = BLI_kdtree_3d_find_nearest(tree, co, NULL);
-				if (i_mirr != -1) {
-					BMVert *v_test = BM_vert_at_index(bm, i_mirr);
-					if (len_squared_v3v3(co, v_test->co) < maxdist_sq) {
-						v_mirr = v_test;
-					}
-				}
-			}
-
-			if (v_mirr && (use_self || (v_mirr != v))) {
-				const int i_mirr = BM_elem_index_get(v_mirr);
-				*idx = i_mirr;
-				idx = VERT_INTPTR(v_mirr, i_mirr);
-				*idx = i;
-			}
-			else {
-				*idx = -1;
-			}
-		}
-
-	}
+  BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
+    BLI_assert(BM_elem_index_get(v) == i);
+
+    /* temporary for testing, check for selection */
+    if (use_select && !BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+      /* do nothing */
+    }
+    else {
+      BMVert *v_mirr;
+      int *idx = VERT_INTPTR(v, i);
+
+      if (use_topology) {
+        v_mirr = cache_mirr_intptr_as_bmvert(mesh_topo_store.index_lookup, i);
+      }
+      else {
+        int i_mirr;
+        float co[3];
+        copy_v3_v3(co, v->co);
+        co[axis] *= -1.0f;
+
+        v_mirr = NULL;
+        i_mirr = BLI_kdtree_3d_find_nearest(tree, co, NULL);
+        if (i_mirr != -1) {
+          BMVert *v_test = BM_vert_at_index(bm, i_mirr);
+          if (len_squared_v3v3(co, v_test->co) < maxdist_sq) {
+            v_mirr = v_test;
+          }
+        }
+      }
+
+      if (v_mirr && (use_self || (v_mirr != v))) {
+        const int i_mirr = BM_elem_index_get(v_mirr);
+        *idx = i_mirr;
+        idx = VERT_INTPTR(v_mirr, i_mirr);
+        *idx = i;
+      }
+      else {
+        *idx = -1;
+      }
+    }
+  }
 
 #undef VERT_INTPTR
 
-	if (use_topology) {
-		ED_mesh_mirrtopo_free(&mesh_topo_store);
-	}
-	else {
-		BLI_kdtree_3d_free(tree);
-	}
+  if (use_topology) {
+    ED_mesh_mirrtopo_free(&mesh_topo_store);
+  }
+  else {
+    BLI_kdtree_3d_free(tree);
+  }
 }
 
-void EDBM_verts_mirror_cache_begin(
-        BMEditMesh *em, const int axis,
-        const bool use_self, const bool use_select,
-        const bool use_topology)
+void EDBM_verts_mirror_cache_begin(BMEditMesh *em,
+                                   const int axis,
+                                   const bool use_self,
+                                   const bool use_select,
+                                   const bool use_topology)
 {
-	EDBM_verts_mirror_cache_begin_ex(
-	        em, axis,
-	        use_self, use_select,
-	        /* extra args */
-	        use_topology, BM_SEARCH_MAXDIST_MIRR, NULL);
+  EDBM_verts_mirror_cache_begin_ex(em,
+                                   axis,
+                                   use_self,
+                                   use_select,
+                                   /* extra args */
+                                   use_topology,
+                                   BM_SEARCH_MAXDIST_MIRR,
+                                   NULL);
 }
 
 BMVert *EDBM_verts_mirror_get(BMEditMesh *em, BMVert *v)
 {
-	const int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
+  const int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
 
-	BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
+  BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
 
-	if (mirr && *mirr >= 0 && *mirr < em->bm->totvert) {
-		if (!em->bm->vtable) {
-			printf("err: should only be called between "
-			       "EDBM_verts_mirror_cache_begin and EDBM_verts_mirror_cache_end");
-			return NULL;
-		}
+  if (mirr && *mirr >= 0 && *mirr < em->bm->totvert) {
+    if (!em->bm->vtable) {
+      printf(
+          "err: should only be called between "
+          "EDBM_verts_mirror_cache_begin and EDBM_verts_mirror_cache_end");
+      return NULL;
+    }
 
-		return em->bm->vtable[*mirr];
-	}
+    return em->bm->vtable[*mirr];
+  }
 
-	return NULL;
+  return NULL;
 }
 
 BMEdge *EDBM_verts_mirror_get_edge(BMEditMesh *em, BMEdge *e)
 {
-	BMVert *v1_mirr = EDBM_verts_mirror_get(em, e->v1);
-	if (v1_mirr) {
-		BMVert *v2_mirr = EDBM_verts_mirror_get(em, e->v2);
-		if (v2_mirr) {
-			return BM_edge_exists(v1_mirr, v2_mirr);
-		}
-	}
-
-	return NULL;
+  BMVert *v1_mirr = EDBM_verts_mirror_get(em, e->v1);
+  if (v1_mirr) {
+    BMVert *v2_mirr = EDBM_verts_mirror_get(em, e->v2);
+    if (v2_mirr) {
+      return BM_edge_exists(v1_mirr, v2_mirr);
+    }
+  }
+
+  return NULL;
 }
 
 BMFace *EDBM_verts_mirror_get_face(BMEditMesh *em, BMFace *f)
 {
-	BMVert **v_mirr_arr = BLI_array_alloca(v_mirr_arr, f->len);
+  BMVert **v_mirr_arr = BLI_array_alloca(v_mirr_arr, f->len);
 
-	BMLoop *l_iter, *l_first;
-	unsigned int i = 0;
+  BMLoop *l_iter, *l_first;
+  unsigned int i = 0;
 
-	l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-	do {
-		if ((v_mirr_arr[i++] = EDBM_verts_mirror_get(em, l_iter->v)) == NULL) {
-			return NULL;
-		}
-	} while ((l_iter = l_iter->next) != l_first);
+  l_iter = l_first = BM_FACE_FIRST_LOOP(f);
+  do {
+    if ((v_mirr_arr[i++] = EDBM_verts_mirror_get(em, l_iter->v)) == NULL) {
+      return NULL;
+    }
+  } while ((l_iter = l_iter->next) != l_first);
 
-	return BM_face_exists(v_mirr_arr, f->len);
+  return BM_face_exists(v_mirr_arr, f->len);
 }
 
 void EDBM_verts_mirror_cache_clear(BMEditMesh *em, BMVert *v)
 {
-	int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
+  int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
 
-	BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
+  BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
 
-	if (mirr) {
-		*mirr = -1;
-	}
+  if (mirr) {
+    *mirr = -1;
+  }
 }
 
 void EDBM_verts_mirror_cache_end(BMEditMesh *em)
 {
-	em->mirror_cdlayer = -1;
+  em->mirror_cdlayer = -1;
 }
 
 void EDBM_verts_mirror_apply(BMEditMesh *em, const int sel_from, const int sel_to)
 {
-	BMIter iter;
-	BMVert *v;
-
-	BLI_assert((em->bm->vtable != NULL) && ((em->bm->elem_table_dirty & BM_VERT) == 0));
-
-	BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-		if (BM_elem_flag_test(v, BM_ELEM_SELECT) == sel_from) {
-			BMVert *mirr = EDBM_verts_mirror_get(em, v);
-			if (mirr) {
-				if (BM_elem_flag_test(mirr, BM_ELEM_SELECT) == sel_to) {
-					copy_v3_v3(mirr->co, v->co);
-					mirr->co[0] *= -1.0f;
-				}
-			}
-		}
-	}
+  BMIter iter;
+  BMVert *v;
+
+  BLI_assert((em->bm->vtable != NULL) && ((em->bm->elem_table_dirty & BM_VERT) == 0));
+
+  BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
+    if (BM_elem_flag_test(v, BM_ELEM_SELECT) == sel_from) {
+      BMVert *mirr = EDBM_verts_mirror_get(em, v);
+      if (mirr) {
+        if (BM_elem_flag_test(mirr, BM_ELEM_SELECT) == sel_to) {
+          copy_v3_v3(mirr->co, v->co);
+          mirr->co[0] *= -1.0f;
+        }
+      }
+    }
+  }
 }
 
 /** \} */
@@ -1202,105 +1240,105 @@ void EDBM_verts_mirror_apply(BMEditMesh *em, const int sel_from, const int sel_t
 /* swap is 0 or 1, if 1 it hides not selected */
 bool EDBM_mesh_hide(BMEditMesh *em, bool swap)
 {
-	BMIter iter;
-	BMElem *ele;
-	int itermode;
-	char hflag_swap = swap ? BM_ELEM_SELECT : 0;
-	bool changed = true;
-
-	if (em->selectmode & SCE_SELECT_VERTEX)
-		itermode = BM_VERTS_OF_MESH;
-	else if (em->selectmode & SCE_SELECT_EDGE)
-		itermode = BM_EDGES_OF_MESH;
-	else
-		itermode = BM_FACES_OF_MESH;
-
-	BM_ITER_MESH (ele, &iter, em->bm, itermode) {
-		if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
-			if (BM_elem_flag_test(ele, BM_ELEM_SELECT) ^ hflag_swap) {
-				BM_elem_hide_set(em->bm, ele, true);
-				changed = true;
-			}
-		}
-	}
-
-	if (changed) {
-		EDBM_selectmode_flush(em);
-	}
-	return changed;
-
-	/* original hide flushing comment (OUTDATED):
-	 * hide happens on least dominant select mode, and flushes up, not down!
-	 * (helps preventing errors in subsurf) */
-	/* - vertex hidden, always means edge is hidden too
-	 * - edge hidden, always means face is hidden too
-	 * - face hidden, only set face hide
-	 * - then only flush back down what's absolute hidden
-	 */
+  BMIter iter;
+  BMElem *ele;
+  int itermode;
+  char hflag_swap = swap ? BM_ELEM_SELECT : 0;
+  bool changed = true;
+
+  if (em->selectmode & SCE_SELECT_VERTEX)
+    itermode = BM_VERTS_OF_MESH;
+  else if (em->selectmode & SCE_SELECT_EDGE)
+    itermode = BM_EDGES_OF_MESH;
+  else
+    itermode = BM_FACES_OF_MESH;
+
+  BM_ITER_MESH (ele, &iter, em->bm, itermode) {
+    if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
+      if (BM_elem_flag_test(ele, BM_ELEM_SELECT) ^ hflag_swap) {
+        BM_elem_hide_set(em->bm, ele, true);
+        changed = true;
+      }
+    }
+  }
+
+  if (changed) {
+    EDBM_selectmode_flush(em);
+  }
+  return changed;
+
+  /* original hide flushing comment (OUTDATED):
+   * hide happens on least dominant select mode, and flushes up, not down!
+   * (helps preventing errors in subsurf) */
+  /* - vertex hidden, always means edge is hidden too
+   * - edge hidden, always means face is hidden too
+   * - face hidden, only set face hide
+   * - then only flush back down what's absolute hidden
+   */
 }
 
 bool EDBM_mesh_reveal(BMEditMesh *em, bool select)
 {
-	const char iter_types[3] = {
-		BM_VERTS_OF_MESH,
-		BM_EDGES_OF_MESH,
-		BM_FACES_OF_MESH,
-	};
-
-	const bool sels[3] = {
-		(em->selectmode & SCE_SELECT_VERTEX) != 0,
-		(em->selectmode & SCE_SELECT_EDGE) != 0,
-		(em->selectmode & SCE_SELECT_FACE) != 0,
-	};
-	int i;
-	bool changed = false;
-
-	/* Use tag flag to remember what was hidden before all is revealed.
-	 * BM_ELEM_HIDDEN --> BM_ELEM_TAG */
-	for (i = 0; i < 3; i++) {
-		BMIter iter;
-		BMElem *ele;
-
-		BM_ITER_MESH (ele, &iter, em->bm, iter_types[i]) {
-			if (BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
-				BM_elem_flag_enable(ele, BM_ELEM_TAG);
-				changed = true;
-			}
-			else {
-				BM_elem_flag_disable(ele, BM_ELEM_TAG);
-			}
-		}
-	}
-
-	if (!changed) {
-		return false;
-	}
-
-	/* Reveal everything */
-	EDBM_flag_disable_all(em, BM_ELEM_HIDDEN);
-
-	/* Select relevant just-revealed elements */
-	for (i = 0; i < 3; i++) {
-		BMIter iter;
-		BMElem *ele;
-
-		if (!sels[i]) {
-			continue;
-		}
-
-		BM_ITER_MESH (ele, &iter, em->bm, iter_types[i]) {
-			if (BM_elem_flag_test(ele, BM_ELEM_TAG)) {
-				BM_elem_select_set(em->bm, ele, select);
-			}
-		}
-	}
-
-	EDBM_selectmode_flush(em);
-
-	/* hidden faces can have invalid normals */
-	EDBM_mesh_normals_update(em);
-
-	return true;
+  const char iter_types[3] = {
+      BM_VERTS_OF_MESH,
+      BM_EDGES_OF_MESH,
+      BM_FACES_OF_MESH,
+  };
+
+  const bool sels[3] = {
+      (em->selectmode & SCE_SELECT_VERTEX) != 0,
+      (em->selectmode & SCE_SELECT_EDGE) != 0,
+      (em->selectmode & SCE_SELECT_FACE) != 0,
+  };
+  int i;
+  bool changed = false;
+
+  /* Use tag flag to remember what was hidden before all is revealed.
+   * BM_ELEM_HIDDEN --> BM_ELEM_TAG */
+  for (i = 0; i < 3; i++) {
+    BMIter iter;
+    BMElem *ele;
+
+    BM_ITER_MESH (ele, &iter, em->bm, iter_types[i]) {
+      if (BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
+        BM_elem_flag_enable(ele, BM_ELEM_TAG);
+        changed = true;
+      }
+      else {
+        BM_elem_flag_disable(ele, BM_ELEM_TAG);
+      }
+    }
+  }
+
+  if (!changed) {
+    return false;
+  }
+
+  /* Reveal everything */
+  EDBM_flag_disable_all(em, BM_ELEM_HIDDEN);
+
+  /* Select relevant just-revealed elements */
+  for (i = 0; i < 3; i++) {
+    BMIter iter;
+    BMElem *ele;
+
+    if (!sels[i]) {
+      continue;
+    }
+
+    BM_ITER_MESH (ele, &iter, em->bm, iter_types[i]) {
+      if (BM_elem_flag_test(ele, BM_ELEM_TAG)) {
+        BM_elem_select_set(em->bm, ele, select);
+      }
+    }
+  }
+
+  EDBM_selectmode_flush(em);
+
+  /* hidden faces can have invalid normals */
+  EDBM_mesh_normals_update(em);
+
+  return true;
 }
 
 /** \} */
@@ -1311,73 +1349,73 @@ bool EDBM_mesh_reveal(BMEditMesh *em, bool select)
 
 void EDBM_mesh_normals_update(BMEditMesh *em)
 {
-	BM_mesh_normals_update(em->bm);
+  BM_mesh_normals_update(em->bm);
 }
 
 void EDBM_stats_update(BMEditMesh *em)
 {
-	const char iter_types[3] = {
-		BM_VERTS_OF_MESH,
-		BM_EDGES_OF_MESH,
-		BM_FACES_OF_MESH,
-	};
-
-	BMIter iter;
-	BMElem *ele;
-	int *tots[3];
-	int i;
-
-	tots[0] = &em->bm->totvertsel;
-	tots[1] = &em->bm->totedgesel;
-	tots[2] = &em->bm->totfacesel;
-
-	em->bm->totvertsel = em->bm->totedgesel = em->bm->totfacesel = 0;
-
-	for (i = 0; i < 3; i++) {
-		ele = BM_iter_new(&iter, em->bm, iter_types[i], NULL);
-		for ( ; ele; ele = BM_iter_step(&iter)) {
-			if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
-				(*tots[i])++;
-			}
-		}
-	}
+  const char iter_types[3] = {
+      BM_VERTS_OF_MESH,
+      BM_EDGES_OF_MESH,
+      BM_FACES_OF_MESH,
+  };
+
+  BMIter iter;
+  BMElem *ele;
+  int *tots[3];
+  int i;
+
+  tots[0] = &em->bm->totvertsel;
+  tots[1] = &em->bm->totedgesel;
+  tots[2] = &em->bm->totfacesel;
+
+  em->bm->totvertsel = em->bm->totedgesel = em->bm->totfacesel = 0;
+
+  for (i = 0; i < 3; i++) {
+    ele = BM_iter_new(&iter, em->bm, iter_types[i], NULL);
+    for (; ele; ele = BM_iter_step(&iter)) {
+      if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
+        (*tots[i])++;
+      }
+    }
+  }
 }
 
 /* so many tools call these that we better make it a generic function.
  */
 void EDBM_update_generic(BMEditMesh *em, const bool do_tessface, const bool is_destructive)
 {
-	Object *ob = em->ob;
-	/* order of calling isn't important */
-	DEG_id_tag_update(ob->data, ID_RECALC_GEOMETRY);
-	WM_main_add_notifier(NC_GEOM | ND_DATA, ob->data);
-
-	if (do_tessface) {
-		BKE_editmesh_tessface_calc(em);
-	}
-
-	if (is_destructive) {
-		/* TODO. we may be able to remove this now! - Campbell */
-		// BM_mesh_elem_table_free(em->bm, BM_ALL_NOLOOP);
-	}
-	else {
-		/* in debug mode double check we didn't need to recalculate */
-		BLI_assert(BM_mesh_elem_table_check(em->bm) == true);
-	}
-	if (em->bm->spacearr_dirty & BM_SPACEARR_BMO_SET) {
-		BM_lnorspace_invalidate(em->bm, false);
-		em->bm->spacearr_dirty &= ~BM_SPACEARR_BMO_SET;
-	}
-	/* don't keep stale derivedMesh data around, see: [#38872] */
-	BKE_editmesh_free_derivedmesh(em);
+  Object *ob = em->ob;
+  /* order of calling isn't important */
+  DEG_id_tag_update(ob->data, ID_RECALC_GEOMETRY);
+  WM_main_add_notifier(NC_GEOM | ND_DATA, ob->data);
+
+  if (do_tessface) {
+    BKE_editmesh_tessface_calc(em);
+  }
+
+  if (is_destructive) {
+    /* TODO. we may be able to remove this now! - Campbell */
+    // BM_mesh_elem_table_free(em->bm, BM_ALL_NOLOOP);
+  }
+  else {
+    /* in debug mode double check we didn't need to recalculate */
+    BLI_assert(BM_mesh_elem_table_check(em->bm) == true);
+  }
+  if (em->bm->spacearr_dirty & BM_SPACEARR_BMO_SET) {
+    BM_lnorspace_invalidate(em->bm, false);
+    em->bm->spacearr_dirty &= ~BM_SPACEARR_BMO_SET;
+  }
+  /* don't keep stale derivedMesh data around, see: [#38872] */
+  BKE_editmesh_free_derivedmesh(em);
 
 #ifdef DEBUG
-	{
-		BMEditSelection *ese;
-		for (ese = em->bm->selected.first; ese; ese = ese->next) {
-			BLI_assert(BM_elem_flag_test(ese->ele, BM_ELEM_SELECT));
-		}
-	}
+  {
+    BMEditSelection *ese;
+    for (ese = em->bm->selected.first; ese; ese = ese->next) {
+      BLI_assert(BM_elem_flag_test(ese->ele, BM_ELEM_SELECT));
+    }
+  }
 #endif
 }
 
@@ -1390,11 +1428,11 @@ void EDBM_update_generic(BMEditMesh *em, const bool do_tessface, const bool is_d
 /* poll call for mesh operators requiring a view3d context */
 bool EDBM_view3d_poll(bContext *C)
 {
-	if (ED_operator_editmesh(C) && ED_operator_view3d_active(C)) {
-		return 1;
-	}
+  if (ED_operator_editmesh(C) && ED_operator_view3d_active(C)) {
+    return 1;
+  }
 
-	return 0;
+  return 0;
 }
 
 /** \} */
@@ -1405,19 +1443,19 @@ bool EDBM_view3d_poll(bContext *C)
 
 BMElem *EDBM_elem_from_selectmode(BMEditMesh *em, BMVert *eve, BMEdge *eed, BMFace *efa)
 {
-	BMElem *ele = NULL;
-
-	if ((em->selectmode & SCE_SELECT_VERTEX) && eve) {
-		ele = (BMElem *)eve;
-	}
-	else if ((em->selectmode & SCE_SELECT_EDGE) && eed) {
-		ele = (BMElem *)eed;
-	}
-	else if ((em->selectmode & SCE_SELECT_FACE) && efa) {
-		ele = (BMElem *)efa;
-	}
-
-	return ele;
+  BMElem *ele = NULL;
+
+  if ((em->selectmode & SCE_SELECT_VERTEX) && eve) {
+    ele = (BMElem *)eve;
+  }
+  else if ((em->selectmode & SCE_SELECT_EDGE) && eed) {
+    ele = (BMElem *)eed;
+  }
+  else if ((em->selectmode & SCE_SELECT_FACE) && efa) {
+    ele = (BMElem *)efa;
+  }
+
+  return ele;
 }
 
 /**
@@ -1427,44 +1465,44 @@ BMElem *EDBM_elem_from_selectmode(BMEditMesh *em, BMVert *eve, BMEdge *eed, BMFa
  */
 int EDBM_elem_to_index_any(BMEditMesh *em, BMElem *ele)
 {
-	BMesh *bm = em->bm;
-	int index = BM_elem_index_get(ele);
-
-	if (ele->head.htype == BM_VERT) {
-		BLI_assert(!(bm->elem_index_dirty & BM_VERT));
-	}
-	else if (ele->head.htype == BM_EDGE) {
-		BLI_assert(!(bm->elem_index_dirty & BM_EDGE));
-		index += bm->totvert;
-	}
-	else if (ele->head.htype == BM_FACE) {
-		BLI_assert(!(bm->elem_index_dirty & BM_FACE));
-		index += bm->totvert + bm->totedge;
-	}
-	else {
-		BLI_assert(0);
-	}
-
-	return index;
+  BMesh *bm = em->bm;
+  int index = BM_elem_index_get(ele);
+
+  if (ele->head.htype == BM_VERT) {
+    BLI_assert(!(bm->elem_index_dirty & BM_VERT));
+  }
+  else if (ele->head.htype == BM_EDGE) {
+    BLI_assert(!(bm->elem_index_dirty & BM_EDGE));
+    index += bm->totvert;
+  }
+  else if (ele->head.htype == BM_FACE) {
+    BLI_assert(!(bm->elem_index_dirty & BM_FACE));
+    index += bm->totvert + bm->totedge;
+  }
+  else {
+    BLI_assert(0);
+  }
+
+  return index;
 }
 
 BMElem *EDBM_elem_from_index_any(BMEditMesh *em, int index)
 {
-	BMesh *bm = em->bm;
-
-	if (index < bm->totvert) {
-		return (BMElem *)BM_vert_at_index_find_or_table(bm, index);
-	}
-	index -= bm->totvert;
-	if (index < bm->totedge) {
-		return (BMElem *)BM_edge_at_index_find_or_table(bm, index);
-	}
-	index -= bm->totedge;
-	if (index < bm->totface) {
-		return (BMElem *)BM_face_at_index_find_or_table(bm, index);
-	}
-
-	return NULL;
+  BMesh *bm = em->bm;
+
+  if (index < bm->totvert) {
+    return (BMElem *)BM_vert_at_index_find_or_table(bm, index);
+  }
+  index -= bm->totvert;
+  if (index < bm->totedge) {
+    return (BMElem *)BM_edge_at_index_find_or_table(bm, index);
+  }
+  index -= bm->totedge;
+  if (index < bm->totface) {
+    return (BMElem *)BM_face_at_index_find_or_table(bm, index);
+  }
+
+  return NULL;
 }
 
 /** \} */
@@ -1473,83 +1511,87 @@ BMElem *EDBM_elem_from_index_any(BMEditMesh *em, int index)
 /** \name BMesh BVH API
  * \{ */
 
-static BMFace *edge_ray_cast(struct BMBVHTree *tree, const float co[3], const float dir[3], float *r_hitout, BMEdge *e)
+static BMFace *edge_ray_cast(
+    struct BMBVHTree *tree, const float co[3], const float dir[3], float *r_hitout, BMEdge *e)
 {
-	BMFace *f = BKE_bmbvh_ray_cast(tree, co, dir, 0.0f, NULL, r_hitout, NULL);
+  BMFace *f = BKE_bmbvh_ray_cast(tree, co, dir, 0.0f, NULL, r_hitout, NULL);
 
-	if (f && BM_edge_in_face(e, f)) {
-		return NULL;
-	}
+  if (f && BM_edge_in_face(e, f)) {
+    return NULL;
+  }
 
-	return f;
+  return f;
 }
 
 static void scale_point(float c1[3], const float p[3], const float s)
 {
-	sub_v3_v3(c1, p);
-	mul_v3_fl(c1, s);
-	add_v3_v3(c1, p);
+  sub_v3_v3(c1, p);
+  mul_v3_fl(c1, s);
+  add_v3_v3(c1, p);
 }
 
-bool BMBVH_EdgeVisible(struct BMBVHTree *tree, BMEdge *e,
+bool BMBVH_EdgeVisible(struct BMBVHTree *tree,
+                       BMEdge *e,
                        struct Depsgraph *depsgraph,
-                       ARegion *ar, View3D *v3d, Object *obedit)
+                       ARegion *ar,
+                       View3D *v3d,
+                       Object *obedit)
 {
-	BMFace *f;
-	float co1[3], co2[3], co3[3], dir1[3], dir2[3], dir3[3];
-	float origin[3], invmat[4][4];
-	float epsilon = 0.01f;
-	float end[3];
-	const float mval_f[2] = {
-		ar->winx / 2.0f,
-		ar->winy / 2.0f,
-	};
-
-	ED_view3d_win_to_segment_clipped(depsgraph, ar, v3d, mval_f, origin, end, false);
-
-	invert_m4_m4(invmat, obedit->obmat);
-	mul_m4_v3(invmat, origin);
-
-	copy_v3_v3(co1, e->v1->co);
-	mid_v3_v3v3(co2, e->v1->co, e->v2->co);
-	copy_v3_v3(co3, e->v2->co);
-
-	scale_point(co1, co2, 0.99);
-	scale_point(co3, co2, 0.99);
-
-	/* ok, idea is to generate rays going from the camera origin to the
-	 * three points on the edge (v1, mid, v2)*/
-	sub_v3_v3v3(dir1, origin, co1);
-	sub_v3_v3v3(dir2, origin, co2);
-	sub_v3_v3v3(dir3, origin, co3);
-
-	normalize_v3_length(dir1, epsilon);
-	normalize_v3_length(dir2, epsilon);
-	normalize_v3_length(dir3, epsilon);
-
-	/* offset coordinates slightly along view vectors, to avoid
-	 * hitting the faces that own the edge.*/
-	add_v3_v3v3(co1, co1, dir1);
-	add_v3_v3v3(co2, co2, dir2);
-	add_v3_v3v3(co3, co3, dir3);
-
-	normalize_v3(dir1);
-	normalize_v3(dir2);
-	normalize_v3(dir3);
-
-	/* do three samplings: left, middle, right */
-	f = edge_ray_cast(tree, co1, dir1, NULL, e);
-	if (f && !edge_ray_cast(tree, co2, dir2, NULL, e)) {
-		return true;
-	}
-	else if (f && !edge_ray_cast(tree, co3, dir3, NULL, e)) {
-		return true;
-	}
-	else if (!f) {
-		return true;
-	}
-
-	return false;
+  BMFace *f;
+  float co1[3], co2[3], co3[3], dir1[3], dir2[3], dir3[3];
+  float origin[3], invmat[4][4];
+  float epsilon = 0.01f;
+  float end[3];
+  const float mval_f[2] = {
+      ar->winx / 2.0f,
+      ar->winy / 2.0f,
+  };
+
+  ED_view3d_win_to_segment_clipped(depsgraph, ar, v3d, mval_f, origin, end, false);
+
+  invert_m4_m4(invmat, obedit->obmat);
+  mul_m4_v3(invmat, origin);
+
+  copy_v3_v3(co1, e->v1->co);
+  mid_v3_v3v3(co2, e->v1->co, e->v2->co);
+  copy_v3_v3(co3, e->v2->co);
+
+  scale_point(co1, co2, 0.99);
+  scale_point(co3, co2, 0.99);
+
+  /* ok, idea is to generate rays going from the camera origin to the
+   * three points on the edge (v1, mid, v2)*/
+  sub_v3_v3v3(dir1, origin, co1);
+  sub_v3_v3v3(dir2, origin, co2);
+  sub_v3_v3v3(dir3, origin, co3);
+
+  normalize_v3_length(dir1, epsilon);
+  normalize_v3_length(dir2, epsilon);
+  normalize_v3_length(dir3, epsilon);
+
+  /* offset coordinates slightly along view vectors, to avoid
+   * hitting the faces that own the edge.*/
+  add_v3_v3v3(co1, co1, dir1);
+  add_v3_v3v3(co2, co2, dir2);
+  add_v3_v3v3(co3, co3, dir3);
+
+  normalize_v3(dir1);
+  normalize_v3(dir2);
+  normalize_v3(dir3);
+
+  /* do three samplings: left, middle, right */
+  f = edge_ray_cast(tree, co1, dir1, NULL, e);
+  if (f && !edge_ray_cast(tree, co2, dir2, NULL, e)) {
+    return true;
+  }
+  else if (f && !edge_ray_cast(tree, co3, dir3, NULL, e)) {
+    return true;
+  }
+  else if (!f) {
+    return true;
+  }
+
+  return false;
 }
 
 /** \} */