Cleanup: Use signed integers in the weld modifier

The style guide mentions that unsigned integers shouldn't be used to
show that a value won't be negative. Many places don't follow this
properly yet. The modifier used to cast an array of `uint` to `int` in
order to pass it to `BLI_kdtree_3d_calc_duplicates_fast`. That is no
longer necessary.

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

1 files changed, 301 insertions, 301 deletions

diff --git a/source/blender/modifiers/intern/MOD_weld.c b/source/blender/modifiers/intern/MOD_weld.c
index f842bef3298..aa19e84b909 100644
--- a/source/blender/modifiers/intern/MOD_weld.c
+++ b/source/blender/modifiers/intern/MOD_weld.c
@@ -70,68 +70,68 @@
 #include "MOD_ui_common.h"
 
 /* Indicates when the element was not computed. */
-#define OUT_OF_CONTEXT (uint)(-1)
+#define OUT_OF_CONTEXT (int)(-1)
 /* Indicates if the edge or face will be collapsed. */
-#define ELEM_COLLAPSED (uint)(-2)
+#define ELEM_COLLAPSED (int)(-2)
 /* indicates whether an edge or vertex in groups_map will be merged. */
-#define ELEM_MERGED (uint)(-2)
+#define ELEM_MERGED (int)(-2)
 
 /* Used to indicate a range in an array specifying a group. */
 struct WeldGroup {
-  uint len;
-  uint ofs;
+  int len;
+  int ofs;
 };
 
 /* Edge groups that will be merged. Final vertices are also indicated. */
 struct WeldGroupEdge {
   struct WeldGroup group;
-  uint v1;
-  uint v2;
+  int v1;
+  int v2;
 };
 
 typedef struct WeldVert {
   /* Indexes relative to the original Mesh. */
-  uint vert_dest;
-  uint vert_orig;
+  int vert_dest;
+  int vert_orig;
 } WeldVert;
 
 typedef struct WeldEdge {
   union {
-    uint flag;
+    int flag;
     struct {
       /* Indexes relative to the original Mesh. */
-      uint edge_dest;
-      uint edge_orig;
-      uint vert_a;
-      uint vert_b;
+      int edge_dest;
+      int edge_orig;
+      int vert_a;
+      int vert_b;
     };
   };
 } WeldEdge;
 
 typedef struct WeldLoop {
   union {
-    uint flag;
+    int flag;
     struct {
       /* Indexes relative to the original Mesh. */
-      uint vert;
-      uint edge;
-      uint loop_orig;
-      uint loop_skip_to;
+      int vert;
+      int edge;
+      int loop_orig;
+      int loop_skip_to;
     };
   };
 } WeldLoop;
 
 typedef struct WeldPoly {
   union {
-    uint flag;
+    int flag;
     struct {
       /* Indexes relative to the original Mesh. */
-      uint poly_dst;
-      uint poly_orig;
-      uint loop_start;
-      uint loop_end;
+      int poly_dst;
+      int poly_orig;
+      int loop_start;
+      int loop_end;
       /* Final Polygon Size. */
-      uint len;
+      int len;
       /* Group of loops that will be affected. */
       struct WeldGroup loops;
     };
@@ -141,53 +141,53 @@ typedef struct WeldPoly {
 typedef struct WeldMesh {
   /* Group of vertices to be merged. */
   struct WeldGroup *vert_groups;
-  uint *vert_groups_buffer;
+  int *vert_groups_buffer;
 
   /* Group of edges to be merged. */
   struct WeldGroupEdge *edge_groups;
-  uint *edge_groups_buffer;
+  int *edge_groups_buffer;
   /* From the original index of the vertex, this indicates which group it is or is going to be
    * merged. */
-  uint *edge_groups_map;
+  int *edge_groups_map;
 
   /* References all polygons and loops that will be affected. */
   WeldLoop *wloop;
   WeldPoly *wpoly;
   WeldPoly *wpoly_new;
-  uint wloop_len;
-  uint wpoly_len;
-  uint wpoly_new_len;
+  int wloop_len;
+  int wpoly_len;
+  int wpoly_new_len;
 
   /* From the actual index of the element in the mesh, it indicates what is the index of the Weld
    * element above. */
-  uint *loop_map;
-  uint *poly_map;
+  int *loop_map;
+  int *poly_map;
 
-  uint vert_kill_len;
-  uint edge_kill_len;
-  uint loop_kill_len;
-  uint poly_kill_len; /* Including the new polygons. */
+  int vert_kill_len;
+  int edge_kill_len;
+  int loop_kill_len;
+  int poly_kill_len; /* Including the new polygons. */
 
   /* Size of the affected polygon with more sides. */
-  uint max_poly_len;
+  int max_poly_len;
 } WeldMesh;
 
 typedef struct WeldLoopOfPolyIter {
-  uint loop_start;
-  uint loop_end;
+  int loop_start;
+  int loop_end;
   const WeldLoop *wloop;
   const MLoop *mloop;
-  const uint *loop_map;
+  const int *loop_map;
   /* Weld group. */
-  uint *group;
+  int *group;
 
-  uint l_curr;
-  uint l_next;
+  int l_curr;
+  int l_next;
 
   /* Return */
-  uint group_len;
-  uint v;
-  uint e;
+  int group_len;
+  int v;
+  int e;
   char type;
 } WeldLoopOfPolyIter;
 
@@ -200,19 +200,19 @@ static bool weld_iter_loop_of_poly_begin(WeldLoopOfPolyIter *iter,
                                          const WeldPoly *wp,
                                          const WeldLoop *wloop,
                                          const MLoop *mloop,
-                                         const uint *loop_map,
-                                         uint *group_buffer);
+                                         const int *loop_map,
+                                         int *group_buffer);
 
 static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter);
 
 static void weld_assert_edge_kill_len(const WeldEdge *wedge,
-                                      const uint wedge_len,
-                                      const uint supposed_kill_len)
+                                      const int wedge_len,
+                                      const int supposed_kill_len)
 {
-  uint kills = 0;
+  int kills = 0;
   const WeldEdge *we = &wedge[0];
-  for (uint i = wedge_len; i--; we++) {
-    uint edge_dest = we->edge_dest;
+  for (int i = wedge_len; i--; we++) {
+    int edge_dest = we->edge_dest;
     /* Magically includes collapsed edges. */
     if (edge_dest != OUT_OF_CONTEXT) {
       kills++;
@@ -223,22 +223,22 @@ static void weld_assert_edge_kill_len(const WeldEdge *wedge,
 
 static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
                                                const WeldPoly *wpoly_new,
-                                               const uint wpoly_new_len,
+                                               const int wpoly_new_len,
                                                const WeldLoop *wloop,
                                                const MLoop *mloop,
-                                               const uint *loop_map,
-                                               const uint *poly_map,
+                                               const int *loop_map,
+                                               const int *poly_map,
                                                const MPoly *mpoly,
-                                               const uint mpoly_len,
-                                               const uint mloop_len,
-                                               const uint supposed_poly_kill_len,
-                                               const uint supposed_loop_kill_len)
+                                               const int mpoly_len,
+                                               const int mloop_len,
+                                               const int supposed_poly_kill_len,
+                                               const int supposed_loop_kill_len)
 {
-  uint poly_kills = 0;
-  uint loop_kills = mloop_len;
+  int poly_kills = 0;
+  int loop_kills = mloop_len;
   const MPoly *mp = &mpoly[0];
-  for (uint i = 0; i < mpoly_len; i++, mp++) {
-    uint poly_ctx = poly_map[i];
+  for (int i = 0; i < mpoly_len; i++, mp++) {
+    int poly_ctx = poly_map[i];
     if (poly_ctx != OUT_OF_CONTEXT) {
       const WeldPoly *wp = &wpoly[poly_ctx];
       WeldLoopOfPolyIter iter;
@@ -251,11 +251,11 @@ static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
           poly_kills++;
           continue;
         }
-        uint remain = wp->len;
-        uint l = wp->loop_start;
+        int remain = wp->len;
+        int l = wp->loop_start;
         while (remain) {
-          uint l_next = l + 1;
-          uint loop_ctx = loop_map[l];
+          int l_next = l + 1;
+          int loop_ctx = loop_map[l];
           if (loop_ctx != OUT_OF_CONTEXT) {
             const WeldLoop *wl = &wloop[loop_ctx];
             if (wl->loop_skip_to != OUT_OF_CONTEXT) {
@@ -280,16 +280,16 @@ static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
   }
 
   const WeldPoly *wp = &wpoly_new[0];
-  for (uint i = wpoly_new_len; i--; wp++) {
+  for (int i = wpoly_new_len; i--; wp++) {
     if (wp->poly_dst != OUT_OF_CONTEXT) {
       poly_kills++;
       continue;
     }
-    uint remain = wp->len;
-    uint l = wp->loop_start;
+    int remain = wp->len;
+    int l = wp->loop_start;
     while (remain) {
-      uint l_next = l + 1;
-      uint loop_ctx = loop_map[l];
+      int l_next = l + 1;
+      int loop_ctx = loop_map[l];
       if (loop_ctx != OUT_OF_CONTEXT) {
         const WeldLoop *wl = &wloop[loop_ctx];
         if (wl->loop_skip_to != OUT_OF_CONTEXT) {
@@ -315,24 +315,24 @@ static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
 static void weld_assert_poly_no_vert_repetition(const WeldPoly *wp,
                                                 const WeldLoop *wloop,
                                                 const MLoop *mloop,
-                                                const uint *loop_map)
+                                                const int *loop_map)
 {
-  const uint len = wp->len;
-  uint *verts = BLI_array_alloca(verts, len);
+  const int len = wp->len;
+  int *verts = BLI_array_alloca(verts, len);
   WeldLoopOfPolyIter iter;
   if (!weld_iter_loop_of_poly_begin(&iter, wp, wloop, mloop, loop_map, NULL)) {
     return;
   }
   else {
-    uint i = 0;
+    int i = 0;
     while (weld_iter_loop_of_poly_next(&iter)) {
       verts[i++] = iter.v;
     }
   }
-  for (uint i = 0; i < len; i++) {
-    uint va = verts[i];
-    for (uint j = i + 1; j < len; j++) {
-      uint vb = verts[j];
+  for (int i = 0; i < len; i++) {
+    int va = verts[i];
+    for (int j = i + 1; j < len; j++) {
+      int vb = verts[j];
       BLI_assert(va != vb);
     }
   }
@@ -344,14 +344,14 @@ static void weld_assert_poly_len(const WeldPoly *wp, const WeldLoop *wloop)
     return;
   }
 
-  uint len = wp->len;
+  int len = wp->len;
   const WeldLoop *wl = &wloop[wp->loops.ofs];
   BLI_assert(wp->loop_start <= wl->loop_orig);
 
-  uint end_wloop = wp->loops.ofs + wp->loops.len;
+  int end_wloop = wp->loops.ofs + wp->loops.len;
   const WeldLoop *wl_end = &wloop[end_wloop - 1];
 
-  uint min_len = 0;
+  int min_len = 0;
   for (; wl <= wl_end; wl++) {
     BLI_assert(wl->loop_skip_to == OUT_OF_CONTEXT); /* Not for this case. */
     if (wl->flag != ELEM_COLLAPSED) {
@@ -360,7 +360,7 @@ static void weld_assert_poly_len(const WeldPoly *wp, const WeldLoop *wloop)
   }
   BLI_assert(len >= min_len);
 
-  uint max_len = wp->loop_end - wp->loop_start + 1;
+  int max_len = wp->loop_end - wp->loop_start + 1;
   BLI_assert(len <= max_len);
 }
 
@@ -372,20 +372,20 @@ static void weld_assert_poly_len(const WeldPoly *wp, const WeldLoop *wloop)
 /** \name Weld Vert API
  * \{ */
 
-static void weld_vert_ctx_alloc_and_setup(const uint mvert_len,
-                                          uint *r_vert_dest_map,
+static void weld_vert_ctx_alloc_and_setup(const int mvert_len,
+                                          int *r_vert_dest_map,
                                           WeldVert **r_wvert,
-                                          uint *r_wvert_len)
+                                          int *r_wvert_len)
 {
   /* Vert Context. */
-  uint wvert_len = 0;
+  int wvert_len = 0;
 
   WeldVert *wvert, *wv;
   wvert = MEM_mallocN(sizeof(*wvert) * mvert_len, __func__);
   wv = &wvert[0];
 
-  uint *v_dest_iter = &r_vert_dest_map[0];
-  for (uint i = 0; i < mvert_len; i++, v_dest_iter++) {
+  int *v_dest_iter = &r_vert_dest_map[0];
+  for (int i = 0; i < mvert_len; i++, v_dest_iter++) {
     if (*v_dest_iter != OUT_OF_CONTEXT) {
       wv->vert_dest = *v_dest_iter;
       wv->vert_orig = i;
@@ -398,21 +398,21 @@ static void weld_vert_ctx_alloc_and_setup(const uint mvert_len,
   *r_wvert_len = wvert_len;
 }
 
-static void weld_vert_groups_setup(const uint mvert_len,
-                                   const uint wvert_len,
+static void weld_vert_groups_setup(const int mvert_len,
+                                   const int wvert_len,
                                    const WeldVert *wvert,
-                                   const uint *vert_dest_map,
-                                   uint *r_vert_groups_map,
-                                   uint **r_vert_groups_buffer,
+                                   const int *vert_dest_map,
+                                   int *r_vert_groups_map,
+                                   int **r_vert_groups_buffer,
                                    struct WeldGroup **r_vert_groups)
 {
   /* Get weld vert groups. */
 
-  uint wgroups_len = 0;
-  const uint *vert_dest_iter = &vert_dest_map[0];
-  uint *group_map_iter = &r_vert_groups_map[0];
-  for (uint i = 0; i < mvert_len; i++, group_map_iter++, vert_dest_iter++) {
-    uint vert_dest = *vert_dest_iter;
+  int wgroups_len = 0;
+  const int *vert_dest_iter = &vert_dest_map[0];
+  int *group_map_iter = &r_vert_groups_map[0];
+  for (int i = 0; i < mvert_len; i++, group_map_iter++, vert_dest_iter++) {
+    int vert_dest = *vert_dest_iter;
     if (vert_dest != OUT_OF_CONTEXT) {
       if (vert_dest != i) {
         *group_map_iter = ELEM_MERGED;
@@ -430,29 +430,29 @@ static void weld_vert_groups_setup(const uint mvert_len,
   struct WeldGroup *wgroups = MEM_callocN(sizeof(*wgroups) * wgroups_len, __func__);
 
   const WeldVert *wv = &wvert[0];
-  for (uint i = wvert_len; i--; wv++) {
-    uint group_index = r_vert_groups_map[wv->vert_dest];
+  for (int i = wvert_len; i--; wv++) {
+    int group_index = r_vert_groups_map[wv->vert_dest];
     wgroups[group_index].len++;
   }
 
-  uint ofs = 0;
+  int ofs = 0;
   struct WeldGroup *wg_iter = &wgroups[0];
-  for (uint i = wgroups_len; i--; wg_iter++) {
+  for (int i = wgroups_len; i--; wg_iter++) {
     wg_iter->ofs = ofs;
     ofs += wg_iter->len;
   }
 
   BLI_assert(ofs == wvert_len);
 
-  uint *groups_buffer = MEM_mallocN(sizeof(*groups_buffer) * ofs, __func__);
+  int *groups_buffer = MEM_mallocN(sizeof(*groups_buffer) * ofs, __func__);
   wv = &wvert[0];
-  for (uint i = wvert_len; i--; wv++) {
-    uint group_index = r_vert_groups_map[wv->vert_dest];
+  for (int i = wvert_len; i--; wv++) {
+    int group_index = r_vert_groups_map[wv->vert_dest];
     groups_buffer[wgroups[group_index].ofs++] = wv->vert_orig;
   }
 
   wg_iter = &wgroups[0];
-  for (uint i = wgroups_len; i--; wg_iter++) {
+  for (int i = wgroups_len; i--; wg_iter++) {
     wg_iter->ofs -= wg_iter->len;
   }
 
@@ -466,26 +466,26 @@ static void weld_vert_groups_setup(const uint mvert_len,
 /** \name Weld Edge API
  * \{ */
 
-static void weld_edge_ctx_setup(const uint mvert_len,
-                                const uint wedge_len,
+static void weld_edge_ctx_setup(const int mvert_len,
+                                const int wedge_len,
                                 struct WeldGroup *r_vlinks,
-                                uint *r_edge_dest_map,
+                                int *r_edge_dest_map,
                                 WeldEdge *r_wedge,
-                                uint *r_edge_kiil_len)
+                                int *r_edge_kiil_len)
 {
   WeldEdge *we;
 
   /* Setup Edge Overlap. */
-  uint edge_kill_len = 0;
+  int edge_kill_len = 0;
 
   struct WeldGroup *vl_iter, *v_links;
   v_links = r_vlinks;
   vl_iter = &v_links[0];
 
   we = &r_wedge[0];
-  for (uint i = wedge_len; i--; we++) {
-    uint dst_vert_a = we->vert_a;
-    uint dst_vert_b = we->vert_b;
+  for (int i = wedge_len; i--; we++) {
+    int dst_vert_a = we->vert_a;
+    int dst_vert_b = we->vert_b;
 
     if (dst_vert_a == dst_vert_b) {
       BLI_assert(we->edge_dest == OUT_OF_CONTEXT);
@@ -499,62 +499,62 @@ static void weld_edge_ctx_setup(const uint mvert_len,
     v_links[dst_vert_b].len++;
   }
 
-  uint link_len = 0;
+  int link_len = 0;
   vl_iter = &v_links[0];
-  for (uint i = mvert_len; i--; vl_iter++) {
+  for (int i = mvert_len; i--; vl_iter++) {
     vl_iter->ofs = link_len;
     link_len += vl_iter->len;
   }
 
   if (link_len) {
-    uint *link_edge_buffer = MEM_mallocN(sizeof(*link_edge_buffer) * link_len, __func__);
+    int *link_edge_buffer = MEM_mallocN(sizeof(*link_edge_buffer) * link_len, __func__);
 
     we = &r_wedge[0];
-    for (uint i = 0; i < wedge_len; i++, we++) {
+    for (int i = 0; i < wedge_len; i++, we++) {
       if (we->flag == ELEM_COLLAPSED) {
         continue;
       }
 
-      uint dst_vert_a = we->vert_a;
-      uint dst_vert_b = we->vert_b;
+      int dst_vert_a = we->vert_a;
+      int dst_vert_b = we->vert_b;
 
       link_edge_buffer[v_links[dst_vert_a].ofs++] = i;
       link_edge_buffer[v_links[dst_vert_b].ofs++] = i;
     }
 
     vl_iter = &v_links[0];
-    for (uint i = mvert_len; i--; vl_iter++) {
+    for (int i = mvert_len; i--; vl_iter++) {
       /* Fix offset */
       vl_iter->ofs -= vl_iter->len;
     }
 
     we = &r_wedge[0];
-    for (uint i = 0; i < wedge_len; i++, we++) {
+    for (int i = 0; i < wedge_len; i++, we++) {
       if (we->edge_dest != OUT_OF_CONTEXT) {
         /* No need to retest edges.
          * (Already includes collapsed edges). */
         continue;
       }
 
-      uint dst_vert_a = we->vert_a;
-      uint dst_vert_b = we->vert_b;
+      int dst_vert_a = we->vert_a;
+      int dst_vert_b = we->vert_b;
 
       struct WeldGroup *link_a = &v_links[dst_vert_a];
       struct WeldGroup *link_b = &v_links[dst_vert_b];
 
-      uint edges_len_a = link_a->len;
-      uint edges_len_b = link_b->len;
+      int edges_len_a = link_a->len;
+      int edges_len_b = link_b->len;
 
       if (edges_len_a <= 1 || edges_len_b <= 1) {
         continue;
       }
 
-      uint *edges_ctx_a = &link_edge_buffer[link_a->ofs];
-      uint *edges_ctx_b = &link_edge_buffer[link_b->ofs];
-      uint edge_orig = we->edge_orig;
+      int *edges_ctx_a = &link_edge_buffer[link_a->ofs];
+      int *edges_ctx_b = &link_edge_buffer[link_b->ofs];
+      int edge_orig = we->edge_orig;
 
       for (; edges_len_a--; edges_ctx_a++) {
-        uint e_ctx_a = *edges_ctx_a;
+        int e_ctx_a = *edges_ctx_a;
         if (e_ctx_a == i) {
           continue;
         }
@@ -565,7 +565,7 @@ static void weld_edge_ctx_setup(const uint mvert_len,
         if (edges_len_b == 0) {
           break;
         }
-        uint e_ctx_b = *edges_ctx_b;
+        int e_ctx_b = *edges_ctx_b;
         if (e_ctx_a == e_ctx_b) {
           WeldEdge *we_b = &r_wedge[e_ctx_b];
           BLI_assert(ELEM(we_b->vert_a, dst_vert_a, dst_vert_b));
@@ -590,29 +590,29 @@ static void weld_edge_ctx_setup(const uint mvert_len,
 }
 
 static void weld_edge_ctx_alloc(const MEdge *medge,
-                                const uint medge_len,
-                                const uint *vert_dest_map,
-                                uint *r_edge_dest_map,
-                                uint **r_edge_ctx_map,
+                                const int medge_len,
+                                const int *vert_dest_map,
+                                int *r_edge_dest_map,
+                                int **r_edge_ctx_map,
                                 WeldEdge **r_wedge,
-                                uint *r_wedge_len)
+                                int *r_wedge_len)
 {
   /* Edge Context. */
-  uint *edge_map = MEM_mallocN(sizeof(*edge_map) * medge_len, __func__);
-  uint wedge_len = 0;
+  int *edge_map = MEM_mallocN(sizeof(*edge_map) * medge_len, __func__);
+  int wedge_len = 0;
 
   WeldEdge *wedge, *we;
   wedge = MEM_mallocN(sizeof(*wedge) * medge_len, __func__);
   we = &wedge[0];
 
   const MEdge *me = &medge[0];
-  uint *e_dest_iter = &r_edge_dest_map[0];
-  uint *iter = &edge_map[0];
-  for (uint i = 0; i < medge_len; i++, me++, iter++, e_dest_iter++) {
-    uint v1 = me->v1;
-    uint v2 = me->v2;
-    uint v_dest_1 = vert_dest_map[v1];
-    uint v_dest_2 = vert_dest_map[v2];
+  int *e_dest_iter = &r_edge_dest_map[0];
+  int *iter = &edge_map[0];
+  for (int i = 0; i < medge_len; i++, me++, iter++, e_dest_iter++) {
+    int v1 = me->v1;
+    int v2 = me->v2;
+    int v_dest_1 = vert_dest_map[v1];
+    int v_dest_2 = vert_dest_map[v2];
     if ((v_dest_1 != OUT_OF_CONTEXT) || (v_dest_2 != OUT_OF_CONTEXT)) {
       we->vert_a = (v_dest_1 != OUT_OF_CONTEXT) ? v_dest_1 : v1;
       we->vert_b = (v_dest_2 != OUT_OF_CONTEXT) ? v_dest_2 : v2;
@@ -633,13 +633,13 @@ static void weld_edge_ctx_alloc(const MEdge *medge,
   *r_edge_ctx_map = edge_map;
 }
 
-static void weld_edge_groups_setup(const uint medge_len,
-                                   const uint edge_kill_len,
-                                   const uint wedge_len,
+static void weld_edge_groups_setup(const int medge_len,
+                                   const int edge_kill_len,
+                                   const int wedge_len,
                                    WeldEdge *wedge,
-                                   const uint *wedge_map,
-                                   uint *r_edge_groups_map,
-                                   uint **r_edge_groups_buffer,
+                                   const int *wedge_map,
+                                   int *r_edge_groups_map,
+                                   int **r_edge_groups_buffer,
                                    struct WeldGroupEdge **r_edge_groups)
 {
 
@@ -647,18 +647,18 @@ static void weld_edge_groups_setup(const uint medge_len,
 
   struct WeldGroupEdge *wegroups, *wegrp_iter;
 
-  uint wgroups_len = wedge_len - edge_kill_len;
+  int wgroups_len = wedge_len - edge_kill_len;
   wegroups = MEM_callocN(sizeof(*wegroups) * wgroups_len, __func__);
   wegrp_iter = &wegroups[0];
 
   wgroups_len = 0;
-  const uint *edge_ctx_iter = &wedge_map[0];
-  uint *group_map_iter = &r_edge_groups_map[0];
-  for (uint i = medge_len; i--; edge_ctx_iter++, group_map_iter++) {
-    uint edge_ctx = *edge_ctx_iter;
+  const int *edge_ctx_iter = &wedge_map[0];
+  int *group_map_iter = &r_edge_groups_map[0];
+  for (int i = medge_len; i--; edge_ctx_iter++, group_map_iter++) {
+    int edge_ctx = *edge_ctx_iter;
     if (edge_ctx != OUT_OF_CONTEXT) {
       WeldEdge *we = &wedge[edge_ctx];
-      uint edge_dest = we->edge_dest;
+      int edge_dest = we->edge_dest;
       if (edge_dest != OUT_OF_CONTEXT) {
         BLI_assert(edge_dest != we->edge_orig);
         *group_map_iter = ELEM_MERGED;
@@ -680,33 +680,33 @@ static void weld_edge_groups_setup(const uint medge_len,
   BLI_assert(wgroups_len == wedge_len - edge_kill_len);
 
   WeldEdge *we = &wedge[0];
-  for (uint i = wedge_len; i--; we++) {
+  for (int i = wedge_len; i--; we++) {
     if (we->flag == ELEM_COLLAPSED) {
       continue;
     }
-    uint group_index = r_edge_groups_map[we->edge_dest];
+    int group_index = r_edge_groups_map[we->edge_dest];
     wegroups[group_index].group.len++;
   }
 
-  uint ofs = 0;
+  int ofs = 0;
   wegrp_iter = &wegroups[0];
-  for (uint i = wgroups_len; i--; wegrp_iter++) {
+  for (int i = wgroups_len; i--; wegrp_iter++) {
     wegrp_iter->group.ofs = ofs;
     ofs += wegrp_iter->group.len;
   }
 
-  uint *groups_buffer = MEM_mallocN(sizeof(*groups_buffer) * ofs, __func__);
+  int *groups_buffer = MEM_mallocN(sizeof(*groups_buffer) * ofs, __func__);
   we = &wedge[0];
-  for (uint i = wedge_len; i--; we++) {
+  for (int i = wedge_len; i--; we++) {
     if (we->flag == ELEM_COLLAPSED) {
       continue;
     }
-    uint group_index = r_edge_groups_map[we->edge_dest];
+    int group_index = r_edge_groups_map[we->edge_dest];
     groups_buffer[wegroups[group_index].group.ofs++] = we->edge_orig;
   }
 
   wegrp_iter = &wegroups[0];
-  for (uint i = wgroups_len; i--; wegrp_iter++) {
+  for (int i = wgroups_len; i--; wegrp_iter++) {
     wegrp_iter->group.ofs -= wegrp_iter->group.len;
   }
 
@@ -724,8 +724,8 @@ static bool weld_iter_loop_of_poly_begin(WeldLoopOfPolyIter *iter,
                                          const WeldPoly *wp,
                                          const WeldLoop *wloop,
                                          const MLoop *mloop,
-                                         const uint *loop_map,
-                                         uint *group_buffer)
+                                         const int *loop_map,
+                                         int *group_buffer)
 {
   if (wp->flag == ELEM_COLLAPSED) {
     return false;
@@ -738,14 +738,14 @@ static bool weld_iter_loop_of_poly_begin(WeldLoopOfPolyIter *iter,
   iter->loop_map = loop_map;
   iter->group = group_buffer;
 
-  uint group_len = 0;
+  int group_len = 0;
   if (group_buffer) {
     /* First loop group needs more attention. */
-    uint loop_start, loop_end, l;
+    int loop_start, loop_end, l;
     loop_start = iter->loop_start;
     loop_end = l = iter->loop_end;
     while (l >= loop_start) {
-      const uint loop_ctx = loop_map[l];
+      const int loop_ctx = loop_map[l];
       if (loop_ctx != OUT_OF_CONTEXT) {
         const WeldLoop *wl = &wloop[loop_ctx];
         if (wl->flag == ELEM_COLLAPSED) {
@@ -774,10 +774,10 @@ static bool weld_iter_loop_of_poly_begin(WeldLoopOfPolyIter *iter,
 
 static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter)
 {
-  uint loop_end = iter->loop_end;
+  int loop_end = iter->loop_end;
   const WeldLoop *wloop = iter->wloop;
-  const uint *loop_map = iter->loop_map;
-  uint l = iter->l_curr = iter->l_next;
+  const int *loop_map = iter->loop_map;
+  int l = iter->l_curr = iter->l_next;
   if (l == iter->loop_start) {
     /* `grupo_len` is already calculated in the first loop */
   }
@@ -785,8 +785,8 @@ static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter)
     iter->group_len = 0;
   }
   while (l <= loop_end) {
-    uint l_next = l + 1;
-    const uint loop_ctx = loop_map[l];
+    int l_next = l + 1;
+    const int loop_ctx = loop_map[l];
     if (loop_ctx != OUT_OF_CONTEXT) {
       const WeldLoop *wl = &wloop[loop_ctx];
       if (wl->loop_skip_to != OUT_OF_CONTEXT) {
@@ -809,7 +809,7 @@ static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter)
     else {
       const MLoop *ml = &iter->mloop[l];
 #ifdef USE_WELD_DEBUG
-      BLI_assert(iter->v != ml->v);
+      BLI_assert((uint)iter->v != ml->v);
 #endif
       iter->v = ml->v;
       iter->e = ml->e;
@@ -826,19 +826,19 @@ static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter)
 }
 
 static void weld_poly_loop_ctx_alloc(const MPoly *mpoly,
-                                     const uint mpoly_len,
+                                     const int mpoly_len,
                                      const MLoop *mloop,
-                                     const uint mloop_len,
-                                     const uint *vert_dest_map,
-                                     const uint *edge_dest_map,
+                                     const int mloop_len,
+                                     const int *vert_dest_map,
+                                     const int *edge_dest_map,
                                      WeldMesh *r_weld_mesh)
 {
   /* Loop/Poly Context. */
-  uint *loop_map = MEM_mallocN(sizeof(*loop_map) * mloop_len, __func__);
-  uint *poly_map = MEM_mallocN(sizeof(*poly_map) * mpoly_len, __func__);
-  uint wloop_len = 0;
-  uint wpoly_len = 0;
-  uint max_ctx_poly_len = 4;
+  int *loop_map = MEM_mallocN(sizeof(*loop_map) * mloop_len, __func__);
+  int *poly_map = MEM_mallocN(sizeof(*poly_map) * mpoly_len, __func__);
+  int wloop_len = 0;
+  int wpoly_len = 0;
+  int max_ctx_poly_len = 4;
 
   WeldLoop *wloop, *wl;
   wloop = MEM_mallocN(sizeof(*wloop) * mloop_len, __func__);
@@ -848,25 +848,25 @@ static void weld_poly_loop_ctx_alloc(const MPoly *mpoly,
   wpoly = MEM_mallocN(sizeof(*wpoly) * mpoly_len, __func__);
   wp = &wpoly[0];
 
-  uint maybe_new_poly = 0;
+  int maybe_new_poly = 0;
 
   const MPoly *mp = &mpoly[0];
-  uint *iter = &poly_map[0];
-  uint *loop_map_iter = &loop_map[0];
-  for (uint i = 0; i < mpoly_len; i++, mp++, iter++) {
-    const uint loopstart = mp->loopstart;
-    const uint totloop = mp->totloop;
+  int *iter = &poly_map[0];
+  int *loop_map_iter = &loop_map[0];
+  for (int i = 0; i < mpoly_len; i++, mp++, iter++) {
+    const int loopstart = mp->loopstart;
+    const int totloop = mp->totloop;
 
-    uint vert_ctx_len = 0;
+    int vert_ctx_len = 0;
 
-    uint l = loopstart;
-    uint prev_wloop_len = wloop_len;
+    int l = loopstart;
+    int prev_wloop_len = wloop_len;
     const MLoop *ml = &mloop[l];
-    for (uint j = totloop; j--; l++, ml++, loop_map_iter++) {
-      uint v = ml->v;
-      uint e = ml->e;
-      uint v_dest = vert_dest_map[v];
-      uint e_dest = edge_dest_map[e];
+    for (int j = totloop; j--; l++, ml++, loop_map_iter++) {
+      int v = ml->v;
+      int e = ml->e;
+      int v_dest = vert_dest_map[v];
+      int e_dest = edge_dest_map[e];
       bool is_vert_ctx = v_dest != OUT_OF_CONTEXT;
       bool is_edge_ctx = e_dest != OUT_OF_CONTEXT;
       if (is_vert_ctx) {
@@ -886,7 +886,7 @@ static void weld_poly_loop_ctx_alloc(const MPoly *mpoly,
       }
     }
     if (wloop_len != prev_wloop_len) {
-      uint loops_len = wloop_len - prev_wloop_len;
+      int loops_len = wloop_len - prev_wloop_len;
 
       wp->poly_dst = OUT_OF_CONTEXT;
       wp->poly_orig = i;
@@ -899,7 +899,7 @@ static void weld_poly_loop_ctx_alloc(const MPoly *mpoly,
 
       *iter = wpoly_len++;
       if (totloop > 5 && vert_ctx_len > 1) {
-        uint max_new = (totloop / 3) - 1;
+        int max_new = (totloop / 3) - 1;
         vert_ctx_len /= 2;
         maybe_new_poly += MIN2(max_new, vert_ctx_len);
         CLAMP_MIN(max_ctx_poly_len, totloop);
@@ -930,24 +930,24 @@ static void weld_poly_loop_ctx_alloc(const MPoly *mpoly,
   r_weld_mesh->max_poly_len = max_ctx_poly_len;
 }
 
-static void weld_poly_split_recursive(const uint *vert_dest_map,
+static void weld_poly_split_recursive(const int *vert_dest_map,
 #ifdef USE_WELD_DEBUG
                                       const MLoop *mloop,
 #endif
-                                      uint ctx_verts_len,
+                                      int ctx_verts_len,
                                       WeldPoly *r_wp,
                                       WeldMesh *r_weld_mesh,
-                                      uint *r_poly_kill,
-                                      uint *r_loop_kill)
+                                      int *r_poly_kill,
+                                      int *r_loop_kill)
 {
-  uint poly_len = r_wp->len;
+  int poly_len = r_wp->len;
   if (poly_len > 3 && ctx_verts_len > 1) {
-    const uint ctx_loops_len = r_wp->loops.len;
-    const uint ctx_loops_ofs = r_wp->loops.ofs;
+    const int ctx_loops_len = r_wp->loops.len;
+    const int ctx_loops_ofs = r_wp->loops.ofs;
     WeldLoop *wloop = r_weld_mesh->wloop;
     WeldPoly *wpoly_new = r_weld_mesh->wpoly_new;
 
-    uint loop_kill = 0;
+    int loop_kill = 0;
 
     WeldLoop *poly_loops = &wloop[ctx_loops_ofs];
     WeldLoop *wla = &poly_loops[0];
@@ -955,19 +955,19 @@ static void weld_poly_split_recursive(const uint *vert_dest_map,
     while (wla_prev->flag == ELEM_COLLAPSED) {
       wla_prev--;
     }
-    const uint la_len = ctx_loops_len - 1;
-    for (uint la = 0; la < la_len; la++, wla++) {
+    const int la_len = ctx_loops_len - 1;
+    for (int la = 0; la < la_len; la++, wla++) {
     wa_continue:
       if (wla->flag == ELEM_COLLAPSED) {
         continue;
       }
-      uint vert_a = wla->vert;
+      int vert_a = wla->vert;
       /* Only test vertices that will be merged. */
       if (vert_dest_map[vert_a] != OUT_OF_CONTEXT) {
-        uint lb = la + 1;
+        int lb = la + 1;
         WeldLoop *wlb = wla + 1;
         WeldLoop *wlb_prev = wla;
-        uint killed_ab = 0;
+        int killed_ab = 0;
         ctx_verts_len = 1;
         for (; lb < ctx_loops_len; lb++, wlb++) {
           BLI_assert(wlb->loop_skip_to == OUT_OF_CONTEXT);
@@ -975,13 +975,13 @@ static void weld_poly_split_recursive(const uint *vert_dest_map,
             killed_ab++;
             continue;
           }
-          uint vert_b = wlb->vert;
+          int vert_b = wlb->vert;
           if (vert_dest_map[vert_b] != OUT_OF_CONTEXT) {
             ctx_verts_len++;
           }
           if (vert_a == vert_b) {
-            const uint dist_a = wlb->loop_orig - wla->loop_orig - killed_ab;
-            const uint dist_b = poly_len - dist_a;
+            const int dist_a = wlb->loop_orig - wla->loop_orig - killed_ab;
+            const int dist_b = poly_len - dist_a;
 
             BLI_assert(dist_a != 0 && dist_b != 0);
             if (dist_a == 1 || dist_b == 1) {
@@ -1015,8 +1015,8 @@ static void weld_poly_split_recursive(const uint *vert_dest_map,
                 poly_len -= 2;
               }
               if (wl_tmp == NULL) {
-                const uint new_loops_len = lb - la;
-                const uint new_loops_ofs = ctx_loops_ofs + la;
+                const int new_loops_len = lb - la;
+                const int new_loops_ofs = ctx_loops_ofs + la;
 
                 WeldPoly *new_wp = &wpoly_new[r_weld_mesh->wpoly_new_len++];
                 new_wp->poly_dst = OUT_OF_CONTEXT;
@@ -1073,16 +1073,16 @@ static void weld_poly_split_recursive(const uint *vert_dest_map,
 static void weld_poly_loop_ctx_setup(const MLoop *mloop,
 #ifdef USE_WELD_DEBUG
                                      const MPoly *mpoly,
-                                     const uint mpoly_len,
-                                     const uint mloop_len,
+                                     const int mpoly_len,
+                                     const int mloop_len,
 #endif
-                                     const uint mvert_len,
-                                     const uint *vert_dest_map,
-                                     const uint remain_edge_ctx_len,
+                                     const int mvert_len,
+                                     const int *vert_dest_map,
+                                     const int remain_edge_ctx_len,
                                      struct WeldGroup *r_vlinks,
                                      WeldMesh *r_weld_mesh)
 {
-  uint poly_kill_len, loop_kill_len, wpoly_len, wpoly_new_len;
+  int poly_kill_len, loop_kill_len, wpoly_len, wpoly_new_len;
 
   WeldPoly *wpoly_new, *wpoly, *wp;
   WeldLoop *wloop, *wl;
@@ -1095,22 +1095,22 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
   poly_kill_len = 0;
   loop_kill_len = 0;
 
-  const uint *loop_map = r_weld_mesh->loop_map;
+  const int *loop_map = r_weld_mesh->loop_map;
 
   if (remain_edge_ctx_len) {
 
     /* Setup Poly/Loop. */
 
     wp = &wpoly[0];
-    for (uint i = wpoly_len; i--; wp++) {
-      const uint ctx_loops_len = wp->loops.len;
-      const uint ctx_loops_ofs = wp->loops.ofs;
+    for (int i = wpoly_len; i--; wp++) {
+      const int ctx_loops_len = wp->loops.len;
+      const int ctx_loops_ofs = wp->loops.ofs;
 
-      uint poly_len = wp->len;
-      uint ctx_verts_len = 0;
+      int poly_len = wp->len;
+      int ctx_verts_len = 0;
       wl = &wloop[ctx_loops_ofs];
-      for (uint l = ctx_loops_len; l--; wl++) {
-        const uint edge_dest = wl->edge;
+      for (int l = ctx_loops_len; l--; wl++) {
+        const int edge_dest = wl->edge;
         if (edge_dest == ELEM_COLLAPSED) {
           wl->flag = ELEM_COLLAPSED;
           if (poly_len == 3) {
@@ -1124,7 +1124,7 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
           poly_len--;
         }
         else {
-          const uint vert_dst = wl->vert;
+          const int vert_dst = wl->vert;
           if (vert_dest_map[vert_dst] != OUT_OF_CONTEXT) {
             ctx_verts_len++;
           }
@@ -1168,13 +1168,13 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
 
     /* Setup Polygon Overlap. */
 
-    uint wpoly_and_new_len = wpoly_len + wpoly_new_len;
+    int wpoly_and_new_len = wpoly_len + wpoly_new_len;
 
     struct WeldGroup *vl_iter, *v_links = r_vlinks;
     memset(v_links, 0, sizeof(*v_links) * mvert_len);
 
     wp = &wpoly[0];
-    for (uint i = wpoly_and_new_len; i--; wp++) {
+    for (int i = wpoly_and_new_len; i--; wp++) {
       WeldLoopOfPolyIter iter;
       if (weld_iter_loop_of_poly_begin(&iter, wp, wloop, mloop, loop_map, NULL)) {
         while (weld_iter_loop_of_poly_next(&iter)) {
@@ -1183,18 +1183,18 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
       }
     }
 
-    uint link_len = 0;
+    int link_len = 0;
     vl_iter = &v_links[0];
-    for (uint i = mvert_len; i--; vl_iter++) {
+    for (int i = mvert_len; i--; vl_iter++) {
       vl_iter->ofs = link_len;
       link_len += vl_iter->len;
     }
 
     if (link_len) {
-      uint *link_poly_buffer = MEM_mallocN(sizeof(*link_poly_buffer) * link_len, __func__);
+      int *link_poly_buffer = MEM_mallocN(sizeof(*link_poly_buffer) * link_len, __func__);
 
       wp = &wpoly[0];
-      for (uint i = 0; i < wpoly_and_new_len; i++, wp++) {
+      for (int i = 0; i < wpoly_and_new_len; i++, wp++) {
         WeldLoopOfPolyIter iter;
         if (weld_iter_loop_of_poly_begin(&iter, wp, wloop, mloop, loop_map, NULL)) {
           while (weld_iter_loop_of_poly_next(&iter)) {
@@ -1204,16 +1204,16 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
       }
 
       vl_iter = &v_links[0];
-      for (uint i = mvert_len; i--; vl_iter++) {
+      for (int i = mvert_len; i--; vl_iter++) {
         /* Fix offset */
         vl_iter->ofs -= vl_iter->len;
       }
 
-      uint polys_len_a, polys_len_b, *polys_ctx_a, *polys_ctx_b, p_ctx_a, p_ctx_b;
+      int polys_len_a, polys_len_b, *polys_ctx_a, *polys_ctx_b, p_ctx_a, p_ctx_b;
       polys_len_b = p_ctx_b = 0; /* silence warnings */
 
       wp = &wpoly[0];
-      for (uint i = 0; i < wpoly_and_new_len; i++, wp++) {
+      for (int i = 0; i < wpoly_and_new_len; i++, wp++) {
         if (wp->poly_dst != OUT_OF_CONTEXT) {
           /* No need to retest poly.
            * (Already includes collapsed polygons). */
@@ -1229,7 +1229,7 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
           BLI_assert(link_poly_buffer[link_a->ofs] == i);
           continue;
         }
-        uint wp_len = wp->len;
+        int wp_len = wp->len;
         polys_ctx_a = &link_poly_buffer[link_a->ofs];
         for (; polys_len_a--; polys_ctx_a++) {
           p_ctx_a = *polys_ctx_a;
@@ -1289,7 +1289,7 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
     loop_kill_len = r_weld_mesh->wloop_len;
 
     wp = &wpoly[0];
-    for (uint i = wpoly_len; i--; wp++) {
+    for (int i = wpoly_len; i--; wp++) {
       wp->flag = ELEM_COLLAPSED;
     }
   }
@@ -1321,29 +1321,29 @@ static void weld_poly_loop_ctx_setup(const MLoop *mloop,
  * \{ */
 
 static void weld_mesh_context_create(const Mesh *mesh,
-                                     uint *vert_dest_map,
-                                     const uint vert_kill_len,
+                                     int *vert_dest_map,
+                                     const int vert_kill_len,
                                      WeldMesh *r_weld_mesh)
 {
   const MEdge *medge = mesh->medge;
   const MLoop *mloop = mesh->mloop;
   const MPoly *mpoly = mesh->mpoly;
-  const uint mvert_len = mesh->totvert;
-  const uint medge_len = mesh->totedge;
-  const uint mloop_len = mesh->totloop;
-  const uint mpoly_len = mesh->totpoly;
+  const int mvert_len = mesh->totvert;
+  const int medge_len = mesh->totedge;
+  const int mloop_len = mesh->totloop;
+  const int mpoly_len = mesh->totpoly;
 
-  uint *edge_dest_map = MEM_mallocN(sizeof(*edge_dest_map) * medge_len, __func__);
+  int *edge_dest_map = MEM_mallocN(sizeof(*edge_dest_map) * medge_len, __func__);
   struct WeldGroup *v_links = MEM_callocN(sizeof(*v_links) * mvert_len, __func__);
 
   WeldVert *wvert;
-  uint wvert_len;
+  int wvert_len;
   r_weld_mesh->vert_kill_len = vert_kill_len;
   weld_vert_ctx_alloc_and_setup(mvert_len, vert_dest_map, &wvert, &wvert_len);
 
-  uint *edge_ctx_map;
+  int *edge_ctx_map;
   WeldEdge *wedge;
-  uint wedge_len;
+  int wedge_len;
   weld_edge_ctx_alloc(
       medge, medge_len, vert_dest_map, edge_dest_map, &edge_ctx_map, &wedge, &wedge_len);
 
@@ -1411,7 +1411,7 @@ static void weld_mesh_context_free(WeldMesh *weld_mesh)
  * \{ */
 
 static void customdata_weld(
-    const CustomData *source, CustomData *dest, const uint *src_indices, int count, int dest_index)
+    const CustomData *source, CustomData *dest, const int *src_indices, int count, int dest_index)
 {
   if (count == 1) {
     CustomData_copy_data(source, dest, src_indices[0], dest_index, 1);
@@ -1427,8 +1427,8 @@ static void customdata_weld(
 #ifdef USE_WELD_NORMALS
   float no[3] = {0.0f, 0.0f, 0.0f};
 #endif
-  uint crease = 0;
-  uint bweight = 0;
+  int crease = 0;
+  int bweight = 0;
   short flag = 0;
 
   /* interpolates a layer at a time */
@@ -1572,7 +1572,7 @@ static bool bvhtree_weld_overlap_cb(void *userdata, int index_a, int index_b, in
 /** Use for #MOD_WELD_MODE_CONNECTED calculation. */
 struct WeldVertexCluster {
   float co[3];
-  uint merged_verts;
+  int merged_verts;
 };
 
 static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
@@ -1587,7 +1587,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
   const MVert *mvert;
   const MLoop *mloop;
   const MPoly *mpoly, *mp;
-  uint totvert, totedge, totloop, totpoly;
+  int totvert, totedge, totloop, totpoly;
 
   mvert = mesh->mvert;
   totvert = mesh->totvert;
@@ -1601,7 +1601,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
       const bool invert_vgroup = (wmd->flag & MOD_WELD_INVERT_VGROUP) != 0;
       dv = &dvert[0];
       v_mask = BLI_BITMAP_NEW(totvert, __func__);
-      for (uint i = 0; i < totvert; i++, dv++) {
+      for (int i = 0; i < totvert; i++, dv++) {
         const bool found = BKE_defvert_find_weight(dv, defgrp_index) > 0.0f;
         if (found != invert_vgroup) {
           BLI_BITMAP_ENABLE(v_mask, i);
@@ -1613,8 +1613,8 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
   /* From the original index of the vertex.
    * This indicates which vert it is or is going to be merged. */
-  uint *vert_dest_map = MEM_malloc_arrayN(totvert, sizeof(*vert_dest_map), __func__);
-  uint vert_kill_len = 0;
+  int *vert_dest_map = MEM_malloc_arrayN(totvert, sizeof(*vert_dest_map), __func__);
+  int vert_kill_len = 0;
   if (wmd->mode == MOD_WELD_MODE_ALL)
 #ifdef USE_BVHTREEKDOP
   {
@@ -1649,20 +1649,20 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
       free_bvhtree_from_mesh(&treedata);
       if (overlap) {
-        range_vn_u(vert_dest_map, totvert, 0);
+        range_vn_i(vert_dest_map, totvert, 0);
 
         const BVHTreeOverlap *overlap_iter = &overlap[0];
-        for (uint i = 0; i < overlap_len; i++, overlap_iter++) {
-          uint indexA = overlap_iter->indexA;
-          uint indexB = overlap_iter->indexB;
+        for (int i = 0; i < overlap_len; i++, overlap_iter++) {
+          int indexA = overlap_iter->indexA;
+          int indexB = overlap_iter->indexB;
 
           BLI_assert(indexA < indexB);
 
-          uint va_dst = vert_dest_map[indexA];
+          int va_dst = vert_dest_map[indexA];
           while (va_dst != vert_dest_map[va_dst]) {
             va_dst = vert_dest_map[va_dst];
           }
-          uint vb_dst = vert_dest_map[indexB];
+          int vb_dst = vert_dest_map[indexB];
           while (vb_dst != vert_dest_map[vb_dst]) {
             vb_dst = vert_dest_map[vb_dst];
           }
@@ -1670,19 +1670,19 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
             continue;
           }
           if (va_dst > vb_dst) {
-            SWAP(uint, va_dst, vb_dst);
+            SWAP(int, va_dst, vb_dst);
           }
           vert_kill_len++;
           vert_dest_map[vb_dst] = va_dst;
         }
 
         /* Fix #r_vert_dest_map for next step. */
-        for (uint i = 0; i < totvert; i++) {
+        for (int i = 0; i < totvert; i++) {
           if (i == vert_dest_map[i]) {
             vert_dest_map[i] = OUT_OF_CONTEXT;
           }
           else {
-            uint v = i;
+            int v = i;
             while (v != vert_dest_map[v] && vert_dest_map[v] != OUT_OF_CONTEXT) {
               v = vert_dest_map[v];
             }
@@ -1698,7 +1698,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 #else
   {
     KDTree_3d *tree = BLI_kdtree_3d_new(v_mask ? v_mask_act : totvert);
-    for (uint i = 0; i < totvert; i++) {
+    for (int i = 0; i < totvert; i++) {
       if (!v_mask || BLI_BITMAP_TEST(v_mask, i)) {
         BLI_kdtree_3d_insert(tree, i, mvert[i].co);
       }
@@ -1707,7 +1707,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
     BLI_kdtree_3d_balance(tree);
     vert_kill_len = BLI_kdtree_3d_calc_duplicates_fast(
-        tree, wmd->merge_dist, false, (int *)vert_dest_map);
+        tree, wmd->merge_dist, false, vert_dest_map);
     BLI_kdtree_3d_free(tree);
   }
 #endif
@@ -1723,19 +1723,19 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
     struct WeldVertexCluster *vert_clusters = MEM_malloc_arrayN(
         totvert, sizeof(*vert_clusters), __func__);
     struct WeldVertexCluster *vc = &vert_clusters[0];
-    for (uint i = 0; i < totvert; i++, vc++) {
+    for (int i = 0; i < totvert; i++, vc++) {
       copy_v3_v3(vc->co, mvert[i].co);
       vc->merged_verts = 0;
     }
     const float merge_dist_sq = square_f(wmd->merge_dist);
 
-    range_vn_u(vert_dest_map, totvert, 0);
+    range_vn_i(vert_dest_map, totvert, 0);
 
     /* Collapse Edges that are shorter than the threshold. */
     me = &medge[0];
-    for (uint i = 0; i < totedge; i++, me++) {
-      uint v1 = me->v1;
-      uint v2 = me->v2;
+    for (int i = 0; i < totedge; i++, me++) {
+      int v1 = me->v1;
+      int v2 = me->v2;
 
       if (wmd->flag & MOD_WELD_LOOSE_EDGES && (me->flag & ME_LOOSEEDGE) == 0) {
         continue;
@@ -1753,7 +1753,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
         continue;
       }
       if (v1 > v2) {
-        SWAP(uint, v1, v2);
+        SWAP(int, v1, v2);
       }
       struct WeldVertexCluster *v1_cluster = &vert_clusters[v1];
       struct WeldVertexCluster *v2_cluster = &vert_clusters[v2];
@@ -1774,12 +1774,12 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
     MEM_freeN(vert_clusters);
 
-    for (uint i = 0; i < totvert; i++) {
+    for (int i = 0; i < totvert; i++) {
       if (i == vert_dest_map[i]) {
         vert_dest_map[i] = OUT_OF_CONTEXT;
       }
       else {
-        uint v = i;
+        int v = i;
         while ((v != vert_dest_map[v]) && (vert_dest_map[v] != OUT_OF_CONTEXT)) {
           v = vert_dest_map[v];
         }
@@ -1814,10 +1814,10 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
     /* Vertices */
 
-    uint *vert_final = vert_dest_map;
-    uint *index_iter = &vert_final[0];
+    int *vert_final = vert_dest_map;
+    int *index_iter = &vert_final[0];
     int dest_index = 0;
-    for (uint i = 0; i < totvert; i++, index_iter++) {
+    for (int i = 0; i < totvert; i++, index_iter++) {
       int source_index = i;
       int count = 0;
       while (i < totvert && *index_iter == OUT_OF_CONTEXT) {
@@ -1849,10 +1849,10 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
 
     /* Edges */
 
-    uint *edge_final = weld_mesh.edge_groups_map;
+    int *edge_final = weld_mesh.edge_groups_map;
     index_iter = &edge_final[0];
     dest_index = 0;
-    for (uint i = 0; i < totedge; i++, index_iter++) {
+    for (int i = 0; i < totedge; i++, index_iter++) {
       int source_index = i;
       int count = 0;
       while (i < totedge && *index_iter == OUT_OF_CONTEXT) {
@@ -1897,14 +1897,14 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
     mp = &mpoly[0];
     MPoly *r_mp = &result->mpoly[0];
     MLoop *r_ml = &result->mloop[0];
-    uint r_i = 0;
+    int r_i = 0;
     int loop_cur = 0;
-    uint *group_buffer = BLI_array_alloca(group_buffer, weld_mesh.max_poly_len);
-    for (uint i = 0; i < totpoly; i++, mp++) {
+    int *group_buffer = BLI_array_alloca(group_buffer, weld_mesh.max_poly_len);
+    for (int i = 0; i < totpoly; i++, mp++) {
       int loop_start = loop_cur;
-      uint poly_ctx = weld_mesh.poly_map[i];
+      int poly_ctx = weld_mesh.poly_map[i];
       if (poly_ctx == OUT_OF_CONTEXT) {
-        uint mp_loop_len = mp->totloop;
+        int mp_loop_len = mp->totloop;
         CustomData_copy_data(&mesh->ldata, &result->ldata, mp->loopstart, loop_cur, mp_loop_len);
         loop_cur += mp_loop_len;
         for (; mp_loop_len--; r_ml++) {
@@ -1925,8 +1925,8 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
         }
         while (weld_iter_loop_of_poly_next(&iter)) {
           customdata_weld(&mesh->ldata, &result->ldata, group_buffer, iter.group_len, loop_cur);
-          uint v = vert_final[iter.v];
-          uint e = edge_final[iter.e];
+          int v = vert_final[iter.v];
+          int e = edge_final[iter.e];
           r_ml->v = v;
           r_ml->e = e;
           r_ml++;
@@ -1946,7 +1946,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
     }
 
     WeldPoly *wp = &weld_mesh.wpoly_new[0];
-    for (uint i = 0; i < weld_mesh.wpoly_new_len; i++, wp++) {
+    for (int i = 0; i < weld_mesh.wpoly_new_len; i++, wp++) {
       int loop_start = loop_cur;
       WeldLoopOfPolyIter iter;
       if (!weld_iter_loop_of_poly_begin(
@@ -1959,8 +1959,8 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd,
       }
       while (weld_iter_loop_of_poly_next(&iter)) {
         customdata_weld(&mesh->ldata, &result->ldata, group_buffer, iter.group_len, loop_cur);
-        uint v = vert_final[iter.v];
-        uint e = edge_final[iter.e];
+        int v = vert_final[iter.v];
+        int e = edge_final[iter.e];
         r_ml->v = v;
         r_ml->e = e;
         r_ml++;