Cleanup: Rearrange the functions in 'transform_convert_mesh.c'

The creation of `TransCustomData` is best located at the beginning of the
file as it is a specific struct of the file and can be used a lot locally.

1 files changed, 568 insertions, 547 deletions

diff --git a/source/blender/editors/transform/transform_convert_mesh.c b/source/blender/editors/transform/transform_convert_mesh.c
index 872f3e1385a..59f314f5301 100644
--- a/source/blender/editors/transform/transform_convert_mesh.c
+++ b/source/blender/editors/transform/transform_convert_mesh.c
@@ -48,7 +48,575 @@
 
 #include "transform_convert.h"
 
+/* -------------------------------------------------------------------- */
+/** \name Container TransCustomData Creation
+ * \{ */
+
+struct TransCustomDataMergeGroup {
+  /** map {BMVert: TransCustomDataLayerVert} */
+  struct LinkNode **cd_loop_groups;
+};
+
+struct TransCustomDataLayer {
+  BMesh *bm;
+  struct MemArena *arena;
+
+  struct GHash *origfaces;
+  struct BMesh *bm_origfaces;
+
+  /* Special handle for multi-resolution. */
+  int cd_loop_mdisp_offset;
+
+  /* Optionally merge custom-data groups (this keeps UVs connected for example). */
+  struct {
+    /** map {BMVert: TransDataBasic} */
+    struct GHash *origverts;
+    struct TransCustomDataMergeGroup *data;
+    int data_len;
+    /** Array size of 'layer_math_map_len'
+     * maps #TransCustomDataLayerVert.cd_group index to absolute #CustomData layer index */
+    int *customdatalayer_map;
+    /** Number of math BMLoop layers. */
+    int customdatalayer_map_len;
+  } merge_group;
+
+  bool use_merge_group;
+};
+
+static void tc_mesh_customdatacorrect_free_fn(struct TransInfo *UNUSED(t),
+                                              struct TransDataContainer *UNUSED(tc),
+                                              struct TransCustomData *custom_data)
+{
+  struct TransCustomDataLayer *tcld = custom_data->data;
+  bmesh_edit_end(tcld->bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
+
+  if (tcld->bm_origfaces) {
+    BM_mesh_free(tcld->bm_origfaces);
+  }
+  if (tcld->origfaces) {
+    BLI_ghash_free(tcld->origfaces, NULL, NULL);
+  }
+  if (tcld->merge_group.origverts) {
+    BLI_ghash_free(tcld->merge_group.origverts, NULL, NULL);
+  }
+  if (tcld->arena) {
+    BLI_memarena_free(tcld->arena);
+  }
+  if (tcld->merge_group.customdatalayer_map) {
+    MEM_freeN(tcld->merge_group.customdatalayer_map);
+  }
+
+  MEM_freeN(tcld);
+  custom_data->data = NULL;
+}
+
 #define USE_FACE_SUBSTITUTE
+#ifdef USE_FACE_SUBSTITUTE
+#  define FACE_SUBSTITUTE_INDEX INT_MIN
+
+/**
+ * Search for a neighboring face with area and preferably without selected vertex.
+ * Used to replace area-less faces in custom-data correction.
+ */
+static BMFace *tc_mesh_customdatacorrect_find_best_face_substitute(BMFace *f)
+{
+  BMFace *best_face = NULL;
+  BMLoop *l;
+  BMIter liter;
+  BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
+    BMLoop *l_radial_next = l->radial_next;
+    BMFace *f_test = l_radial_next->f;
+    if (f_test == f) {
+      continue;
+    }
+    if (is_zero_v3(f_test->no)) {
+      continue;
+    }
+
+    /* Check the loops edge isn't selected. */
+    if (!BM_elem_flag_test(l_radial_next->v, BM_ELEM_SELECT) &&
+        !BM_elem_flag_test(l_radial_next->next->v, BM_ELEM_SELECT)) {
+      /* Prefer edges with unselected vertices.
+       * Useful for extrude. */
+      best_face = f_test;
+      break;
+    }
+    if (best_face == NULL) {
+      best_face = f_test;
+    }
+  }
+  return best_face;
+}
+
+static void tc_mesh_customdatacorrect_face_substitute_set(struct TransCustomDataLayer *tcld,
+                                                          BMFace *f,
+                                                          BMFace *f_copy)
+{
+  BLI_assert(is_zero_v3(f->no));
+  BMesh *bm = tcld->bm;
+  /* It is impossible to calculate the loops weights of a face without area.
+   * Find a substitute. */
+  BMFace *f_substitute = tc_mesh_customdatacorrect_find_best_face_substitute(f);
+  if (f_substitute) {
+    /* Copy the custom-data from the substitute face. */
+    BMLoop *l_iter, *l_first;
+    l_iter = l_first = BM_FACE_FIRST_LOOP(f);
+    do {
+      BM_loop_interp_from_face(bm, l_iter, f_substitute, false, false);
+    } while ((l_iter = l_iter->next) != l_first);
+
+    /* Use the substitute face as the reference during the transformation. */
+    BMFace *f_substitute_copy = BM_face_copy(tcld->bm_origfaces, bm, f_substitute, true, true);
+
+    /* Hack: reference substitute face in `f_copy->no`.
+     * `tcld->origfaces` is already used to restore the initial value. */
+    BM_elem_index_set(f_copy, FACE_SUBSTITUTE_INDEX);
+    *((BMFace **)&f_copy->no[0]) = f_substitute_copy;
+  }
+}
+
+static BMFace *tc_mesh_customdatacorrect_face_substitute_get(BMFace *f_copy)
+{
+  BLI_assert(BM_elem_index_get(f_copy) == FACE_SUBSTITUTE_INDEX);
+  return *((BMFace **)&f_copy->no[0]);
+}
+
+#endif /* USE_FACE_SUBSTITUTE */
+
+static void tc_mesh_customdatacorrect_init_vert(struct TransCustomDataLayer *tcld,
+                                                struct TransDataBasic *td,
+                                                const int index)
+{
+  BMesh *bm = tcld->bm;
+  BMVert *v = td->extra;
+  BMIter liter;
+  int j, l_num;
+  float *loop_weights;
+
+  // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT) {
+  BM_iter_init(&liter, bm, BM_LOOPS_OF_VERT, v);
+  l_num = liter.count;
+  loop_weights = tcld->use_merge_group ? BLI_array_alloca(loop_weights, l_num) : NULL;
+  for (j = 0; j < l_num; j++) {
+    BMLoop *l = BM_iter_step(&liter);
+    BMLoop *l_prev, *l_next;
+
+    /* Generic custom-data correction. Copy face data. */
+    void **val_p;
+    if (!BLI_ghash_ensure_p(tcld->origfaces, l->f, &val_p)) {
+      BMFace *f_copy = BM_face_copy(tcld->bm_origfaces, bm, l->f, true, true);
+      *val_p = f_copy;
+#ifdef USE_FACE_SUBSTITUTE
+      if (is_zero_v3(l->f->no)) {
+        tc_mesh_customdatacorrect_face_substitute_set(tcld, l->f, f_copy);
+      }
+#endif
+    }
+
+    if (tcld->use_merge_group) {
+      if ((l_prev = BM_loop_find_prev_nodouble(l, l->next, FLT_EPSILON)) &&
+          (l_next = BM_loop_find_next_nodouble(l, l_prev, FLT_EPSILON))) {
+        loop_weights[j] = angle_v3v3v3(l_prev->v->co, l->v->co, l_next->v->co);
+      }
+      else {
+        loop_weights[j] = 0.0f;
+      }
+    }
+  }
+
+  if (tcld->use_merge_group) {
+    /* Store cd_loop_groups. */
+    struct TransCustomDataMergeGroup *merge_data = &tcld->merge_group.data[index];
+    if (l_num != 0) {
+      merge_data->cd_loop_groups = BLI_memarena_alloc(
+          tcld->arena, tcld->merge_group.customdatalayer_map_len * sizeof(void *));
+      for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
+        const int layer_nr = tcld->merge_group.customdatalayer_map[j];
+        merge_data->cd_loop_groups[j] = BM_vert_loop_groups_data_layer_create(
+            bm, v, layer_nr, loop_weights, tcld->arena);
+      }
+    }
+    else {
+      merge_data->cd_loop_groups = NULL;
+    }
+
+    BLI_ghash_insert(tcld->merge_group.origverts, v, td);
+  }
+}
+
+static void tc_mesh_customdatacorrect_init_container_generic(TransDataContainer *UNUSED(tc),
+                                                             struct TransCustomDataLayer *tcld)
+{
+  BMesh *bm = tcld->bm;
+
+  struct GHash *origfaces = BLI_ghash_ptr_new(__func__);
+  struct BMesh *bm_origfaces = BM_mesh_create(&bm_mesh_allocsize_default,
+                                              &((struct BMeshCreateParams){
+                                                  .use_toolflags = false,
+                                              }));
+
+  /* We need to have matching loop custom-data. */
+  BM_mesh_copy_init_customdata_all_layers(bm_origfaces, bm, BM_LOOP, NULL);
+
+  tcld->origfaces = origfaces;
+  tcld->bm_origfaces = bm_origfaces;
+
+  bmesh_edit_begin(bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
+  tcld->cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
+}
+
+static void tc_mesh_customdatacorrect_init_container_merge_group(TransDataContainer *tc,
+                                                                 struct TransCustomDataLayer *tcld)
+{
+  BMesh *bm = tcld->bm;
+  BLI_assert(CustomData_has_math(&bm->ldata));
+
+  /* TODO: We don't need `layer_math_map` when there are no loops linked
+   * to one of the sliding vertices. */
+
+  /* Over allocate, only 'math' layers are indexed. */
+  int *customdatalayer_map = MEM_mallocN(sizeof(int) * bm->ldata.totlayer, __func__);
+  int layer_math_map_len = 0;
+  for (int i = 0; i < bm->ldata.totlayer; i++) {
+    if (CustomData_layer_has_math(&bm->ldata, i)) {
+      customdatalayer_map[layer_math_map_len++] = i;
+    }
+  }
+  BLI_assert(layer_math_map_len != 0);
+
+  tcld->merge_group.data_len = tc->data_len + tc->data_mirror_len;
+  tcld->merge_group.customdatalayer_map = customdatalayer_map;
+  tcld->merge_group.customdatalayer_map_len = layer_math_map_len;
+  tcld->merge_group.origverts = BLI_ghash_ptr_new_ex(__func__, tcld->merge_group.data_len);
+  tcld->merge_group.data = BLI_memarena_alloc(
+      tcld->arena, tcld->merge_group.data_len * sizeof(*tcld->merge_group.data));
+}
+
+struct TransCustomDataLayer *tc_mesh_customdatacorrect_create(TransDataContainer *tc,
+                                                              const bool use_merge_group)
+{
+  BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
+  BMesh *bm = em->bm;
+
+  if (bm->shapenr > 1) {
+    /* Don't do this at all for non-basis shape keys, too easy to
+     * accidentally break uv maps or vertex colors then */
+    /* create copies of faces for custom-data projection. */
+    return NULL;
+  }
+  if (!CustomData_has_math(&bm->ldata) && !CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
+    /* There is no custom-data to correct. */
+    return NULL;
+  }
+
+  struct TransCustomDataLayer *tcld = MEM_callocN(sizeof(*tcld), __func__);
+  tcld->bm = bm;
+  tcld->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
+
+  /* Init `cd_loop_mdisp_offset` to -1 to avoid problems with a valid index. */
+  tcld->cd_loop_mdisp_offset = -1;
+  tcld->use_merge_group = use_merge_group;
+
+  tc_mesh_customdatacorrect_init_container_generic(tc, tcld);
+
+  if (tcld->use_merge_group) {
+    tc_mesh_customdatacorrect_init_container_merge_group(tc, tcld);
+  }
+
+  {
+    /* Setup Verts. */
+    int i = 0;
+
+    TransData *tob = tc->data;
+    for (int j = tc->data_len; j--; tob++, i++) {
+      tc_mesh_customdatacorrect_init_vert(tcld, (TransDataBasic *)tob, i);
+    }
+
+    TransDataMirror *td_mirror = tc->data_mirror;
+    for (int j = tc->data_mirror_len; j--; td_mirror++, i++) {
+      tc_mesh_customdatacorrect_init_vert(tcld, (TransDataBasic *)td_mirror, i);
+    }
+  }
+
+  return tcld;
+}
+
+static void tc_mesh_customdata_create(TransDataContainer *tc, const bool use_merge_group)
+{
+  struct TransCustomDataLayer *customdatacorrect;
+  customdatacorrect = tc_mesh_customdatacorrect_create(tc, use_merge_group);
+
+  if (!customdatacorrect) {
+    return;
+  }
+
+  BLI_assert(tc->custom.type.data == NULL);
+  tc->custom.type.data = customdatacorrect;
+  tc->custom.type.free_cb = tc_mesh_customdatacorrect_free_fn;
+}
+
+void transform_convert_mesh_customdatacorrect_init(TransInfo *t)
+{
+  bool use_merge_group = false;
+  if (ELEM(t->mode, TFM_EDGE_SLIDE, TFM_VERT_SLIDE)) {
+    if (!(t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT_SLIDE)) {
+      /* No custom-data correction. */
+      return;
+    }
+    use_merge_group = true;
+  }
+  else if (ELEM(t->mode,
+                TFM_TRANSLATION,
+                TFM_ROTATION,
+                TFM_RESIZE,
+                TFM_TOSPHERE,
+                TFM_SHEAR,
+                TFM_BEND,
+                TFM_SHRINKFATTEN,
+                TFM_TRACKBALL,
+                TFM_PUSHPULL,
+                TFM_ALIGN)) {
+    {
+      if (!(t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT)) {
+        /* No custom-data correction. */
+        return;
+      }
+      use_merge_group = (t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT_KEEP_CONNECTED) != 0;
+    }
+  }
+  else {
+    return;
+  }
+
+  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
+    if (tc->custom.type.data != NULL) {
+      tc_mesh_customdatacorrect_free_fn(t, tc, &tc->custom.type);
+    }
+
+    tc_mesh_customdata_create(tc, use_merge_group);
+  }
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name CustomData Layer Correction Apply
+ * \{ */
+
+/**
+ * If we're sliding the vert, return its original location, if not, the current location is good.
+ */
+static const float *tc_mesh_vert_orig_co_get(struct TransCustomDataLayer *tcld, BMVert *v)
+{
+  TransDataBasic *td = BLI_ghash_lookup(tcld->merge_group.origverts, v);
+  return td ? td->iloc : v->co;
+}
+
+static void tc_mesh_customdatacorrect_apply_vert(struct TransCustomDataLayer *tcld,
+                                                 struct TransDataBasic *td,
+                                                 struct TransCustomDataMergeGroup *merge_data,
+                                                 bool do_loop_mdisps)
+{
+  BMesh *bm = tcld->bm;
+  BMVert *v = td->extra;
+  const float *co_orig_3d = td->iloc;
+
+  BMIter liter;
+  int j, l_num;
+  float *loop_weights;
+  const bool is_moved = (len_squared_v3v3(v->co, co_orig_3d) > FLT_EPSILON);
+  const bool do_loop_weight = is_moved && tcld->merge_group.customdatalayer_map_len;
+  const float *v_proj_axis = v->no;
+  /* original (l->prev, l, l->next) projections for each loop ('l' remains unchanged) */
+  float v_proj[3][3];
+
+  if (do_loop_weight) {
+    project_plane_normalized_v3_v3v3(v_proj[1], co_orig_3d, v_proj_axis);
+  }
+
+  // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT)
+  BM_iter_init(&liter, bm, BM_LOOPS_OF_VERT, v);
+  l_num = liter.count;
+  loop_weights = do_loop_weight ? BLI_array_alloca(loop_weights, l_num) : NULL;
+  for (j = 0; j < l_num; j++) {
+    BMFace *f_copy; /* the copy of 'f' */
+    BMLoop *l = BM_iter_step(&liter);
+
+    f_copy = BLI_ghash_lookup(tcld->origfaces, l->f);
+
+#ifdef USE_FACE_SUBSTITUTE
+    /* In some faces it is not possible to calculate interpolation,
+     * so we use a substitute. */
+    if (BM_elem_index_get(f_copy) == FACE_SUBSTITUTE_INDEX) {
+      f_copy = tc_mesh_customdatacorrect_face_substitute_get(f_copy);
+    }
+#endif
+
+    /* only loop data, no vertex data since that contains shape keys,
+     * and we do not want to mess up other shape keys */
+    BM_loop_interp_from_face(bm, l, f_copy, false, false);
+
+    /* weight the loop */
+    if (do_loop_weight) {
+      const float eps = 1.0e-8f;
+      const BMLoop *l_prev = l->prev;
+      const BMLoop *l_next = l->next;
+      const float *co_prev = tc_mesh_vert_orig_co_get(tcld, l_prev->v);
+      const float *co_next = tc_mesh_vert_orig_co_get(tcld, l_next->v);
+      bool co_prev_ok;
+      bool co_next_ok;
+
+      /* In the unlikely case that we're next to a zero length edge -
+       * walk around the to the next.
+       *
+       * Since we only need to check if the vertex is in this corner,
+       * its not important _which_ loop - as long as its not overlapping
+       * 'sv->co_orig_3d', see: T45096. */
+      project_plane_normalized_v3_v3v3(v_proj[0], co_prev, v_proj_axis);
+      while (UNLIKELY(((co_prev_ok = (len_squared_v3v3(v_proj[1], v_proj[0]) > eps)) == false) &&
+                      ((l_prev = l_prev->prev) != l->next))) {
+        co_prev = tc_mesh_vert_orig_co_get(tcld, l_prev->v);
+        project_plane_normalized_v3_v3v3(v_proj[0], co_prev, v_proj_axis);
+      }
+      project_plane_normalized_v3_v3v3(v_proj[2], co_next, v_proj_axis);
+      while (UNLIKELY(((co_next_ok = (len_squared_v3v3(v_proj[1], v_proj[2]) > eps)) == false) &&
+                      ((l_next = l_next->next) != l->prev))) {
+        co_next = tc_mesh_vert_orig_co_get(tcld, l_next->v);
+        project_plane_normalized_v3_v3v3(v_proj[2], co_next, v_proj_axis);
+      }
+
+      if (co_prev_ok && co_next_ok) {
+        const float dist = dist_signed_squared_to_corner_v3v3v3(
+            v->co, UNPACK3(v_proj), v_proj_axis);
+
+        loop_weights[j] = (dist >= 0.0f) ? 1.0f : ((dist <= -eps) ? 0.0f : (1.0f + (dist / eps)));
+        if (UNLIKELY(!isfinite(loop_weights[j]))) {
+          loop_weights[j] = 0.0f;
+        }
+      }
+      else {
+        loop_weights[j] = 0.0f;
+      }
+    }
+  }
+
+  if (tcld->use_merge_group) {
+    struct LinkNode **cd_loop_groups = merge_data->cd_loop_groups;
+    if (tcld->merge_group.customdatalayer_map_len && cd_loop_groups) {
+      if (do_loop_weight) {
+        for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
+          BM_vert_loop_groups_data_layer_merge_weights(
+              bm, cd_loop_groups[j], tcld->merge_group.customdatalayer_map[j], loop_weights);
+        }
+      }
+      else {
+        for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
+          BM_vert_loop_groups_data_layer_merge(
+              bm, cd_loop_groups[j], tcld->merge_group.customdatalayer_map[j]);
+        }
+      }
+    }
+  }
+
+  /* Special handling for multires
+   *
+   * Interpolate from every other loop (not ideal)
+   * However values will only be taken from loops which overlap other mdisps.
+   */
+  const bool update_loop_mdisps = is_moved && do_loop_mdisps && (tcld->cd_loop_mdisp_offset != -1);
+  if (update_loop_mdisps) {
+    float(*faces_center)[3] = BLI_array_alloca(faces_center, l_num);
+    BMLoop *l;
+
+    BM_ITER_ELEM_INDEX (l, &liter, v, BM_LOOPS_OF_VERT, j) {
+      BM_face_calc_center_median(l->f, faces_center[j]);
+    }
+
+    BM_ITER_ELEM_INDEX (l, &liter, v, BM_LOOPS_OF_VERT, j) {
+      BMFace *f_copy = BLI_ghash_lookup(tcld->origfaces, l->f);
+      float f_copy_center[3];
+      BMIter liter_other;
+      BMLoop *l_other;
+      int j_other;
+
+      BM_face_calc_center_median(f_copy, f_copy_center);
+
+      BM_ITER_ELEM_INDEX (l_other, &liter_other, v, BM_LOOPS_OF_VERT, j_other) {
+        BM_face_interp_multires_ex(bm,
+                                   l_other->f,
+                                   f_copy,
+                                   faces_center[j_other],
+                                   f_copy_center,
+                                   tcld->cd_loop_mdisp_offset);
+      }
+    }
+  }
+}
+
+static void tc_mesh_customdatacorrect_apply(TransDataContainer *tc, bool is_final)
+{
+  if (!tc->custom.type.data) {
+    return;
+  }
+  struct TransCustomDataLayer *tcld = tc->custom.type.data;
+  const bool use_merge_group = tcld->use_merge_group;
+
+  struct TransCustomDataMergeGroup *merge_data = tcld->merge_group.data;
+  TransData *tob = tc->data;
+  for (int i = tc->data_len; i--; tob++) {
+    tc_mesh_customdatacorrect_apply_vert(tcld, (TransDataBasic *)tob, merge_data, is_final);
+
+    if (use_merge_group) {
+      merge_data++;
+    }
+  }
+
+  TransDataMirror *td_mirror = tc->data_mirror;
+  for (int i = tc->data_mirror_len; i--; td_mirror++) {
+    tc_mesh_customdatacorrect_apply_vert(tcld, (TransDataBasic *)td_mirror, merge_data, is_final);
+
+    if (use_merge_group) {
+      merge_data++;
+    }
+  }
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name CustomData Layer Correction Restore
+ * \{ */
+
+static void tc_mesh_customdatacorrect_restore(struct TransInfo *t)
+{
+  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
+    struct TransCustomDataLayer *tcld = tc->custom.type.data;
+    if (!tcld) {
+      continue;
+    }
+
+    BMesh *bm = tcld->bm;
+    BMesh *bm_copy = tcld->bm_origfaces;
+
+    GHashIterator gh_iter;
+    GHASH_ITER (gh_iter, tcld->origfaces) {
+      BMFace *f = BLI_ghashIterator_getKey(&gh_iter);
+      BMFace *f_copy = BLI_ghashIterator_getValue(&gh_iter);
+      BLI_assert(f->len == f_copy->len);
+
+      BMLoop *l_iter, *l_first, *l_copy;
+      l_iter = l_first = BM_FACE_FIRST_LOOP(f);
+      l_copy = BM_FACE_FIRST_LOOP(f_copy);
+      do {
+        /* TODO: Restore only the elements that transform. */
+        BM_elem_attrs_copy(bm_copy, bm, l_copy, l_iter);
+        l_copy = l_copy->next;
+      } while ((l_iter = l_iter->next) != l_first);
+    }
+  }
+}
+
+/** \} */
 
 /* -------------------------------------------------------------------- */
 /** \name Island Creation
@@ -1032,553 +1600,6 @@ void createTransEditVerts(TransInfo *t)
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name CustomData Layer Correction
- * \{ */
-
-struct TransCustomDataMergeGroup {
-  /** map {BMVert: TransCustomDataLayerVert} */
-  struct LinkNode **cd_loop_groups;
-};
-
-struct TransCustomDataLayer {
-  BMesh *bm;
-  struct MemArena *arena;
-
-  struct GHash *origfaces;
-  struct BMesh *bm_origfaces;
-
-  /* Special handle for multi-resolution. */
-  int cd_loop_mdisp_offset;
-
-  /* Optionally merge custom-data groups (this keeps UVs connected for example). */
-  struct {
-    /** map {BMVert: TransDataBasic} */
-    struct GHash *origverts;
-    struct TransCustomDataMergeGroup *data;
-    int data_len;
-    /** Array size of 'layer_math_map_len'
-     * maps #TransCustomDataLayerVert.cd_group index to absolute #CustomData layer index */
-    int *customdatalayer_map;
-    /** Number of math BMLoop layers. */
-    int customdatalayer_map_len;
-  } merge_group;
-
-  bool use_merge_group;
-};
-
-static void tc_mesh_customdatacorrect_free_fn(struct TransInfo *UNUSED(t),
-                                              struct TransDataContainer *UNUSED(tc),
-                                              struct TransCustomData *custom_data)
-{
-  struct TransCustomDataLayer *tcld = custom_data->data;
-  bmesh_edit_end(tcld->bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
-
-  if (tcld->bm_origfaces) {
-    BM_mesh_free(tcld->bm_origfaces);
-  }
-  if (tcld->origfaces) {
-    BLI_ghash_free(tcld->origfaces, NULL, NULL);
-  }
-  if (tcld->merge_group.origverts) {
-    BLI_ghash_free(tcld->merge_group.origverts, NULL, NULL);
-  }
-  if (tcld->arena) {
-    BLI_memarena_free(tcld->arena);
-  }
-  if (tcld->merge_group.customdatalayer_map) {
-    MEM_freeN(tcld->merge_group.customdatalayer_map);
-  }
-
-  MEM_freeN(tcld);
-  custom_data->data = NULL;
-}
-
-#ifdef USE_FACE_SUBSTITUTE
-
-#  define FACE_SUBSTITUTE_INDEX INT_MIN
-
-/**
- * Search for a neighboring face with area and preferably without selected vertex.
- * Used to replace area-less faces in custom-data correction.
- */
-static BMFace *mesh_customdatacorrect_find_best_face_substitute(BMFace *f)
-{
-  BMFace *best_face = NULL;
-  BMLoop *l;
-  BMIter liter;
-  BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
-    BMLoop *l_radial_next = l->radial_next;
-    BMFace *f_test = l_radial_next->f;
-    if (f_test == f) {
-      continue;
-    }
-    if (is_zero_v3(f_test->no)) {
-      continue;
-    }
-
-    /* Check the loops edge isn't selected. */
-    if (!BM_elem_flag_test(l_radial_next->v, BM_ELEM_SELECT) &&
-        !BM_elem_flag_test(l_radial_next->next->v, BM_ELEM_SELECT)) {
-      /* Prefer edges with unselected vertices.
-       * Useful for extrude. */
-      best_face = f_test;
-      break;
-    }
-    if (best_face == NULL) {
-      best_face = f_test;
-    }
-  }
-  return best_face;
-}
-
-static void mesh_customdatacorrect_face_substitute_set(struct TransCustomDataLayer *tcld,
-                                                       BMFace *f,
-                                                       BMFace *f_copy)
-{
-  BLI_assert(is_zero_v3(f->no));
-  BMesh *bm = tcld->bm;
-  /* It is impossible to calculate the loops weights of a face without area.
-   * Find a substitute. */
-  BMFace *f_substitute = mesh_customdatacorrect_find_best_face_substitute(f);
-  if (f_substitute) {
-    /* Copy the custom-data from the substitute face. */
-    BMLoop *l_iter, *l_first;
-    l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-    do {
-      BM_loop_interp_from_face(bm, l_iter, f_substitute, false, false);
-    } while ((l_iter = l_iter->next) != l_first);
-
-    /* Use the substitute face as the reference during the transformation. */
-    BMFace *f_substitute_copy = BM_face_copy(tcld->bm_origfaces, bm, f_substitute, true, true);
-
-    /* Hack: reference substitute face in `f_copy->no`.
-     * `tcld->origfaces` is already used to restore the initial value. */
-    BM_elem_index_set(f_copy, FACE_SUBSTITUTE_INDEX);
-    *((BMFace **)&f_copy->no[0]) = f_substitute_copy;
-  }
-}
-
-static BMFace *tc_mesh_customdatacorrect_face_substitute_get(BMFace *f_copy)
-{
-  BLI_assert(BM_elem_index_get(f_copy) == FACE_SUBSTITUTE_INDEX);
-  return *((BMFace **)&f_copy->no[0]);
-}
-
-#endif /* USE_FACE_SUBSTITUTE */
-
-static void tc_mesh_customdatacorrect_init_vert(struct TransCustomDataLayer *tcld,
-                                                struct TransDataBasic *td,
-                                                const int index)
-{
-  BMesh *bm = tcld->bm;
-  BMVert *v = td->extra;
-  BMIter liter;
-  int j, l_num;
-  float *loop_weights;
-
-  // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT) {
-  BM_iter_init(&liter, bm, BM_LOOPS_OF_VERT, v);
-  l_num = liter.count;
-  loop_weights = tcld->use_merge_group ? BLI_array_alloca(loop_weights, l_num) : NULL;
-  for (j = 0; j < l_num; j++) {
-    BMLoop *l = BM_iter_step(&liter);
-    BMLoop *l_prev, *l_next;
-
-    /* Generic custom-data correction. Copy face data. */
-    void **val_p;
-    if (!BLI_ghash_ensure_p(tcld->origfaces, l->f, &val_p)) {
-      BMFace *f_copy = BM_face_copy(tcld->bm_origfaces, bm, l->f, true, true);
-      *val_p = f_copy;
-#ifdef USE_FACE_SUBSTITUTE
-      if (is_zero_v3(l->f->no)) {
-        mesh_customdatacorrect_face_substitute_set(tcld, l->f, f_copy);
-      }
-#endif
-    }
-
-    if (tcld->use_merge_group) {
-      if ((l_prev = BM_loop_find_prev_nodouble(l, l->next, FLT_EPSILON)) &&
-          (l_next = BM_loop_find_next_nodouble(l, l_prev, FLT_EPSILON))) {
-        loop_weights[j] = angle_v3v3v3(l_prev->v->co, l->v->co, l_next->v->co);
-      }
-      else {
-        loop_weights[j] = 0.0f;
-      }
-    }
-  }
-
-  if (tcld->use_merge_group) {
-    /* Store cd_loop_groups. */
-    struct TransCustomDataMergeGroup *merge_data = &tcld->merge_group.data[index];
-    if (l_num != 0) {
-      merge_data->cd_loop_groups = BLI_memarena_alloc(
-          tcld->arena, tcld->merge_group.customdatalayer_map_len * sizeof(void *));
-      for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
-        const int layer_nr = tcld->merge_group.customdatalayer_map[j];
-        merge_data->cd_loop_groups[j] = BM_vert_loop_groups_data_layer_create(
-            bm, v, layer_nr, loop_weights, tcld->arena);
-      }
-    }
-    else {
-      merge_data->cd_loop_groups = NULL;
-    }
-
-    BLI_ghash_insert(tcld->merge_group.origverts, v, td);
-  }
-}
-
-static void tc_mesh_customdatacorrect_init_container_generic(TransDataContainer *UNUSED(tc),
-                                                             struct TransCustomDataLayer *tcld)
-{
-  BMesh *bm = tcld->bm;
-
-  struct GHash *origfaces = BLI_ghash_ptr_new(__func__);
-  struct BMesh *bm_origfaces = BM_mesh_create(&bm_mesh_allocsize_default,
-                                              &((struct BMeshCreateParams){
-                                                  .use_toolflags = false,
-                                              }));
-
-  /* We need to have matching loop custom-data. */
-  BM_mesh_copy_init_customdata_all_layers(bm_origfaces, bm, BM_LOOP, NULL);
-
-  tcld->origfaces = origfaces;
-  tcld->bm_origfaces = bm_origfaces;
-
-  bmesh_edit_begin(bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
-  tcld->cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
-}
-
-static void tc_mesh_customdatacorrect_init_container_merge_group(TransDataContainer *tc,
-                                                                 struct TransCustomDataLayer *tcld)
-{
-  BMesh *bm = tcld->bm;
-  BLI_assert(CustomData_has_math(&bm->ldata));
-
-  /* TODO: We don't need `layer_math_map` when there are no loops linked
-   * to one of the sliding vertices. */
-
-  /* Over allocate, only 'math' layers are indexed. */
-  int *customdatalayer_map = MEM_mallocN(sizeof(int) * bm->ldata.totlayer, __func__);
-  int layer_math_map_len = 0;
-  for (int i = 0; i < bm->ldata.totlayer; i++) {
-    if (CustomData_layer_has_math(&bm->ldata, i)) {
-      customdatalayer_map[layer_math_map_len++] = i;
-    }
-  }
-  BLI_assert(layer_math_map_len != 0);
-
-  tcld->merge_group.data_len = tc->data_len + tc->data_mirror_len;
-  tcld->merge_group.customdatalayer_map = customdatalayer_map;
-  tcld->merge_group.customdatalayer_map_len = layer_math_map_len;
-  tcld->merge_group.origverts = BLI_ghash_ptr_new_ex(__func__, tcld->merge_group.data_len);
-  tcld->merge_group.data = BLI_memarena_alloc(
-      tcld->arena, tcld->merge_group.data_len * sizeof(*tcld->merge_group.data));
-}
-
-static void tc_mesh_customdatacorrect_init_container(TransDataContainer *tc,
-                                                     const bool use_merge_group)
-{
-  if (tc->custom.type.data) {
-    /* The custom-data correction has been initiated before.
-     * Free since some modes have different settings. */
-    tc_mesh_customdatacorrect_free_fn(NULL, tc, &tc->custom.type);
-  }
-
-  BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
-  BMesh *bm = em->bm;
-
-  if (bm->shapenr > 1) {
-    /* Don't do this at all for non-basis shape keys, too easy to
-     * accidentally break uv maps or vertex colors then */
-    /* create copies of faces for custom-data projection. */
-    return;
-  }
-  if (!CustomData_has_math(&bm->ldata) && !CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
-    /* There is no custom-data to correct. */
-    return;
-  }
-
-  struct TransCustomDataLayer *tcld = MEM_callocN(sizeof(*tcld), __func__);
-  tcld->bm = bm;
-  tcld->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
-
-  /* Init `cd_loop_mdisp_offset` to -1 to avoid problems with a valid index. */
-  tcld->cd_loop_mdisp_offset = -1;
-  tcld->use_merge_group = use_merge_group;
-
-  tc_mesh_customdatacorrect_init_container_generic(tc, tcld);
-
-  if (tcld->use_merge_group) {
-    tc_mesh_customdatacorrect_init_container_merge_group(tc, tcld);
-  }
-
-  {
-    /* Setup Verts. */
-    int i = 0;
-
-    TransData *tob = tc->data;
-    for (int j = tc->data_len; j--; tob++, i++) {
-      tc_mesh_customdatacorrect_init_vert(tcld, (TransDataBasic *)tob, i);
-    }
-
-    TransDataMirror *td_mirror = tc->data_mirror;
-    for (int j = tc->data_mirror_len; j--; td_mirror++, i++) {
-      tc_mesh_customdatacorrect_init_vert(tcld, (TransDataBasic *)td_mirror, i);
-    }
-  }
-
-  tc->custom.type.data = tcld;
-  tc->custom.type.free_cb = tc_mesh_customdatacorrect_free_fn;
-}
-
-void transform_convert_mesh_customdatacorrect_init(TransInfo *t)
-{
-  bool use_merge_group = false;
-  if (ELEM(t->mode, TFM_EDGE_SLIDE, TFM_VERT_SLIDE)) {
-    if (!(t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT_SLIDE)) {
-      /* No custom-data correction. */
-      return;
-    }
-    use_merge_group = true;
-  }
-  else if (ELEM(t->mode,
-                TFM_TRANSLATION,
-                TFM_ROTATION,
-                TFM_RESIZE,
-                TFM_TOSPHERE,
-                TFM_SHEAR,
-                TFM_BEND,
-                TFM_SHRINKFATTEN,
-                TFM_TRACKBALL,
-                TFM_PUSHPULL,
-                TFM_ALIGN)) {
-    {
-      if (!(t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT)) {
-        /* No custom-data correction. */
-        return;
-      }
-      use_merge_group = (t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT_KEEP_CONNECTED) != 0;
-    }
-  }
-  else {
-    return;
-  }
-
-  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
-    tc_mesh_customdatacorrect_init_container(tc, use_merge_group);
-  }
-}
-
-/**
- * If we're sliding the vert, return its original location, if not, the current location is good.
- */
-static const float *tc_mesh_vert_orig_co_get(struct TransCustomDataLayer *tcld, BMVert *v)
-{
-  TransDataBasic *td = BLI_ghash_lookup(tcld->merge_group.origverts, v);
-  return td ? td->iloc : v->co;
-}
-
-static void tc_mesh_customdatacorrect_apply_vert(struct TransCustomDataLayer *tcld,
-                                                 struct TransDataBasic *td,
-                                                 struct TransCustomDataMergeGroup *merge_data,
-                                                 bool do_loop_mdisps)
-{
-  BMesh *bm = tcld->bm;
-  BMVert *v = td->extra;
-  const float *co_orig_3d = td->iloc;
-
-  BMIter liter;
-  int j, l_num;
-  float *loop_weights;
-  const bool is_moved = (len_squared_v3v3(v->co, co_orig_3d) > FLT_EPSILON);
-  const bool do_loop_weight = is_moved && tcld->merge_group.customdatalayer_map_len;
-  const float *v_proj_axis = v->no;
-  /* original (l->prev, l, l->next) projections for each loop ('l' remains unchanged) */
-  float v_proj[3][3];
-
-  if (do_loop_weight) {
-    project_plane_normalized_v3_v3v3(v_proj[1], co_orig_3d, v_proj_axis);
-  }
-
-  // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT)
-  BM_iter_init(&liter, bm, BM_LOOPS_OF_VERT, v);
-  l_num = liter.count;
-  loop_weights = do_loop_weight ? BLI_array_alloca(loop_weights, l_num) : NULL;
-  for (j = 0; j < l_num; j++) {
-    BMFace *f_copy; /* the copy of 'f' */
-    BMLoop *l = BM_iter_step(&liter);
-
-    f_copy = BLI_ghash_lookup(tcld->origfaces, l->f);
-
-#ifdef USE_FACE_SUBSTITUTE
-    /* In some faces it is not possible to calculate interpolation,
-     * so we use a substitute. */
-    if (BM_elem_index_get(f_copy) == FACE_SUBSTITUTE_INDEX) {
-      f_copy = tc_mesh_customdatacorrect_face_substitute_get(f_copy);
-    }
-#endif
-
-    /* only loop data, no vertex data since that contains shape keys,
-     * and we do not want to mess up other shape keys */
-    BM_loop_interp_from_face(bm, l, f_copy, false, false);
-
-    /* weight the loop */
-    if (do_loop_weight) {
-      const float eps = 1.0e-8f;
-      const BMLoop *l_prev = l->prev;
-      const BMLoop *l_next = l->next;
-      const float *co_prev = tc_mesh_vert_orig_co_get(tcld, l_prev->v);
-      const float *co_next = tc_mesh_vert_orig_co_get(tcld, l_next->v);
-      bool co_prev_ok;
-      bool co_next_ok;
-
-      /* In the unlikely case that we're next to a zero length edge -
-       * walk around the to the next.
-       *
-       * Since we only need to check if the vertex is in this corner,
-       * its not important _which_ loop - as long as its not overlapping
-       * 'sv->co_orig_3d', see: T45096. */
-      project_plane_normalized_v3_v3v3(v_proj[0], co_prev, v_proj_axis);
-      while (UNLIKELY(((co_prev_ok = (len_squared_v3v3(v_proj[1], v_proj[0]) > eps)) == false) &&
-                      ((l_prev = l_prev->prev) != l->next))) {
-        co_prev = tc_mesh_vert_orig_co_get(tcld, l_prev->v);
-        project_plane_normalized_v3_v3v3(v_proj[0], co_prev, v_proj_axis);
-      }
-      project_plane_normalized_v3_v3v3(v_proj[2], co_next, v_proj_axis);
-      while (UNLIKELY(((co_next_ok = (len_squared_v3v3(v_proj[1], v_proj[2]) > eps)) == false) &&
-                      ((l_next = l_next->next) != l->prev))) {
-        co_next = tc_mesh_vert_orig_co_get(tcld, l_next->v);
-        project_plane_normalized_v3_v3v3(v_proj[2], co_next, v_proj_axis);
-      }
-
-      if (co_prev_ok && co_next_ok) {
-        const float dist = dist_signed_squared_to_corner_v3v3v3(
-            v->co, UNPACK3(v_proj), v_proj_axis);
-
-        loop_weights[j] = (dist >= 0.0f) ? 1.0f : ((dist <= -eps) ? 0.0f : (1.0f + (dist / eps)));
-        if (UNLIKELY(!isfinite(loop_weights[j]))) {
-          loop_weights[j] = 0.0f;
-        }
-      }
-      else {
-        loop_weights[j] = 0.0f;
-      }
-    }
-  }
-
-  if (tcld->use_merge_group) {
-    struct LinkNode **cd_loop_groups = merge_data->cd_loop_groups;
-    if (tcld->merge_group.customdatalayer_map_len && cd_loop_groups) {
-      if (do_loop_weight) {
-        for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
-          BM_vert_loop_groups_data_layer_merge_weights(
-              bm, cd_loop_groups[j], tcld->merge_group.customdatalayer_map[j], loop_weights);
-        }
-      }
-      else {
-        for (j = 0; j < tcld->merge_group.customdatalayer_map_len; j++) {
-          BM_vert_loop_groups_data_layer_merge(
-              bm, cd_loop_groups[j], tcld->merge_group.customdatalayer_map[j]);
-        }
-      }
-    }
-  }
-
-  /* Special handling for multires
-   *
-   * Interpolate from every other loop (not ideal)
-   * However values will only be taken from loops which overlap other mdisps.
-   */
-  const bool update_loop_mdisps = is_moved && do_loop_mdisps && (tcld->cd_loop_mdisp_offset != -1);
-  if (update_loop_mdisps) {
-    float(*faces_center)[3] = BLI_array_alloca(faces_center, l_num);
-    BMLoop *l;
-
-    BM_ITER_ELEM_INDEX (l, &liter, v, BM_LOOPS_OF_VERT, j) {
-      BM_face_calc_center_median(l->f, faces_center[j]);
-    }
-
-    BM_ITER_ELEM_INDEX (l, &liter, v, BM_LOOPS_OF_VERT, j) {
-      BMFace *f_copy = BLI_ghash_lookup(tcld->origfaces, l->f);
-      float f_copy_center[3];
-      BMIter liter_other;
-      BMLoop *l_other;
-      int j_other;
-
-      BM_face_calc_center_median(f_copy, f_copy_center);
-
-      BM_ITER_ELEM_INDEX (l_other, &liter_other, v, BM_LOOPS_OF_VERT, j_other) {
-        BM_face_interp_multires_ex(bm,
-                                   l_other->f,
-                                   f_copy,
-                                   faces_center[j_other],
-                                   f_copy_center,
-                                   tcld->cd_loop_mdisp_offset);
-      }
-    }
-  }
-}
-
-static void tc_mesh_customdatacorrect_apply(TransDataContainer *tc, bool is_final)
-{
-  if (!tc->custom.type.data) {
-    return;
-  }
-  struct TransCustomDataLayer *tcld = tc->custom.type.data;
-  const bool use_merge_group = tcld->use_merge_group;
-
-  struct TransCustomDataMergeGroup *merge_data = tcld->merge_group.data;
-  TransData *tob = tc->data;
-  for (int i = tc->data_len; i--; tob++) {
-    tc_mesh_customdatacorrect_apply_vert(tcld, (TransDataBasic *)tob, merge_data, is_final);
-
-    if (use_merge_group) {
-      merge_data++;
-    }
-  }
-
-  TransDataMirror *td_mirror = tc->data_mirror;
-  for (int i = tc->data_mirror_len; i--; td_mirror++) {
-    tc_mesh_customdatacorrect_apply_vert(tcld, (TransDataBasic *)td_mirror, merge_data, is_final);
-
-    if (use_merge_group) {
-      merge_data++;
-    }
-  }
-}
-
-static void tc_mesh_customdatacorrect_restore(struct TransInfo *t)
-{
-  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
-    struct TransCustomDataLayer *tcld = tc->custom.type.data;
-    if (!tcld) {
-      continue;
-    }
-
-    BMesh *bm = tcld->bm;
-    BMesh *bm_copy = tcld->bm_origfaces;
-
-    GHashIterator gh_iter;
-    GHASH_ITER (gh_iter, tcld->origfaces) {
-      BMFace *f = BLI_ghashIterator_getKey(&gh_iter);
-      BMFace *f_copy = BLI_ghashIterator_getValue(&gh_iter);
-      BLI_assert(f->len == f_copy->len);
-
-      BMLoop *l_iter, *l_first, *l_copy;
-      l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-      l_copy = BM_FACE_FIRST_LOOP(f_copy);
-      do {
-        /* TODO: Restore only the elements that transform. */
-        BM_elem_attrs_copy(bm_copy, bm, l_copy, l_iter);
-        l_copy = l_copy->next;
-      } while ((l_iter = l_iter->next) != l_first);
-    }
-  }
-}
-
-/** \} */
-
-/* -------------------------------------------------------------------- */
 /** \name Recalc Mesh Data
  * \{ */