ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / deform.c
index 3e66490..7769f3a 100644 (file)
@@ -21,7 +21,6 @@
  * \ingroup bke
  */
 
-
 #include <string.h>
 #include <math.h>
 #include <ctype.h>
@@ -45,7 +44,7 @@
 
 #include "BKE_customdata.h"
 #include "BKE_data_transfer.h"
-#include "BKE_deform.h"  /* own include */
+#include "BKE_deform.h" /* own include */
 #include "BKE_mesh.h"
 #include "BKE_mesh_mapping.h"
 #include "BKE_object.h"
 
 #include "data_transfer_intern.h"
 
-
 bDeformGroup *BKE_defgroup_new(Object *ob, const char *name)
 {
-       bDeformGroup *defgroup;
+  bDeformGroup *defgroup;
 
-       BLI_assert(OB_TYPE_SUPPORT_VGROUP(ob->type));
+  BLI_assert(OB_TYPE_SUPPORT_VGROUP(ob->type));
 
-       defgroup = MEM_callocN(sizeof(bDeformGroup), __func__);
+  defgroup = MEM_callocN(sizeof(bDeformGroup), __func__);
 
-       BLI_strncpy(defgroup->name, name, sizeof(defgroup->name));
+  BLI_strncpy(defgroup->name, name, sizeof(defgroup->name));
 
-       BLI_addtail(&ob->defbase, defgroup);
-       defgroup_unique_name(defgroup, ob);
+  BLI_addtail(&ob->defbase, defgroup);
+  defgroup_unique_name(defgroup, ob);
 
-       BKE_object_batch_cache_dirty_tag(ob);
+  BKE_object_batch_cache_dirty_tag(ob);
 
-       return defgroup;
+  return defgroup;
 }
 
 void defgroup_copy_list(ListBase *outbase, const ListBase *inbase)
 {
-       bDeformGroup *defgroup, *defgroupn;
+  bDeformGroup *defgroup, *defgroupn;
 
-       BLI_listbase_clear(outbase);
+  BLI_listbase_clear(outbase);
 
-       for (defgroup = inbase->first; defgroup; defgroup = defgroup->next) {
-               defgroupn = defgroup_duplicate(defgroup);
-               BLI_addtail(outbase, defgroupn);
-       }
+  for (defgroup = inbase->first; defgroup; defgroup = defgroup->next) {
+    defgroupn = defgroup_duplicate(defgroup);
+    BLI_addtail(outbase, defgroupn);
+  }
 }
 
 bDeformGroup *defgroup_duplicate(const bDeformGroup *ingroup)
 {
-       bDeformGroup *outgroup;
+  bDeformGroup *outgroup;
 
-       if (!ingroup) {
-               BLI_assert(0);
-               return NULL;
-       }
+  if (!ingroup) {
+    BLI_assert(0);
+    return NULL;
+  }
 
-       outgroup = MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
+  outgroup = MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
 
-       /* For now, just copy everything over. */
-       memcpy(outgroup, ingroup, sizeof(bDeformGroup));
+  /* For now, just copy everything over. */
+  memcpy(outgroup, ingroup, sizeof(bDeformGroup));
 
-       outgroup->next = outgroup->prev = NULL;
+  outgroup->next = outgroup->prev = NULL;
 
-       return outgroup;
+  return outgroup;
 }
 
 /**
@@ -108,16 +106,17 @@ bDeformGroup *defgroup_duplicate(const bDeformGroup *ingroup)
  * - do nothing if neither are set.
  * - add destination weight if needed
  */
-void defvert_copy_subset(
-        MDeformVert *dvert_dst, const MDeformVert *dvert_src,
-        const bool *vgroup_subset, const int vgroup_tot)
+void defvert_copy_subset(MDeformVert *dvert_dst,
+                         const MDeformVert *dvert_src,
+                         const bool *vgroup_subset,
+                         const int vgroup_tot)
 {
-       int defgroup;
-       for (defgroup = 0; defgroup < vgroup_tot; defgroup++) {
-               if (vgroup_subset[defgroup]) {
-                       defvert_copy_index(dvert_dst, defgroup, dvert_src, defgroup);
-               }
-       }
+  int defgroup;
+  for (defgroup = 0; defgroup < vgroup_tot; defgroup++) {
+    if (vgroup_subset[defgroup]) {
+      defvert_copy_index(dvert_dst, defgroup, dvert_src, defgroup);
+    }
+  }
 }
 
 /**
@@ -125,36 +124,38 @@ void defvert_copy_subset(
  * - do nothing if neither are set.
  * - add destination weight if needed
  */
-void defvert_mirror_subset(
-        MDeformVert *dvert_dst, const MDeformVert *dvert_src,
-        const bool *vgroup_subset, const int vgroup_tot,
-        const int *flip_map, const int flip_map_len)
+void defvert_mirror_subset(MDeformVert *dvert_dst,
+                           const MDeformVert *dvert_src,
+                           const bool *vgroup_subset,
+                           const int vgroup_tot,
+                           const int *flip_map,
+                           const int flip_map_len)
 {
-       int defgroup;
-       for (defgroup = 0; defgroup < vgroup_tot && defgroup < flip_map_len; defgroup++) {
-               if (vgroup_subset[defgroup] && (dvert_dst != dvert_src || flip_map[defgroup] != defgroup)) {
-                       defvert_copy_index(dvert_dst, flip_map[defgroup], dvert_src, defgroup);
-               }
-       }
+  int defgroup;
+  for (defgroup = 0; defgroup < vgroup_tot && defgroup < flip_map_len; defgroup++) {
+    if (vgroup_subset[defgroup] && (dvert_dst != dvert_src || flip_map[defgroup] != defgroup)) {
+      defvert_copy_index(dvert_dst, flip_map[defgroup], dvert_src, defgroup);
+    }
+  }
 }
 
 void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
 {
-       if (dvert_dst->totweight == dvert_src->totweight) {
-               if (dvert_src->totweight)
-                       memcpy(dvert_dst->dw, dvert_src->dw, dvert_src->totweight * sizeof(MDeformWeight));
-       }
-       else {
-               if (dvert_dst->dw)
-                       MEM_freeN(dvert_dst->dw);
-
-               if (dvert_src->totweight)
-                       dvert_dst->dw = MEM_dupallocN(dvert_src->dw);
-               else
-                       dvert_dst->dw = NULL;
-
-               dvert_dst->totweight = dvert_src->totweight;
-       }
+  if (dvert_dst->totweight == dvert_src->totweight) {
+    if (dvert_src->totweight)
+      memcpy(dvert_dst->dw, dvert_src->dw, dvert_src->totweight * sizeof(MDeformWeight));
+  }
+  else {
+    if (dvert_dst->dw)
+      MEM_freeN(dvert_dst->dw);
+
+    if (dvert_src->totweight)
+      dvert_dst->dw = MEM_dupallocN(dvert_src->dw);
+    else
+      dvert_dst->dw = NULL;
+
+    dvert_dst->totweight = dvert_src->totweight;
+  }
 }
 
 /**
@@ -162,27 +163,28 @@ void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
  * - do nothing if neither are set.
  * - add destination weight if needed.
  */
-void defvert_copy_index(
-        MDeformVert       *dvert_dst, const int defgroup_dst,
-        const MDeformVert *dvert_src, const int defgroup_src)
+void defvert_copy_index(MDeformVert *dvert_dst,
+                        const int defgroup_dst,
+                        const MDeformVert *dvert_src,
+                        const int defgroup_src)
 {
-       MDeformWeight *dw_src, *dw_dst;
-
-       dw_src = defvert_find_index(dvert_src, defgroup_src);
-
-       if (dw_src) {
-               /* source is valid, verify destination */
-               dw_dst = defvert_verify_index(dvert_dst, defgroup_dst);
-               dw_dst->weight = dw_src->weight;
-       }
-       else {
-               /* source was NULL, assign zero, could also remove */
-               dw_dst = defvert_find_index(dvert_dst, defgroup_dst);
-
-               if (dw_dst) {
-                       dw_dst->weight = 0.0f;
-               }
-       }
+  MDeformWeight *dw_src, *dw_dst;
+
+  dw_src = defvert_find_index(dvert_src, defgroup_src);
+
+  if (dw_src) {
+    /* source is valid, verify destination */
+    dw_dst = defvert_verify_index(dvert_dst, defgroup_dst);
+    dw_dst->weight = dw_src->weight;
+  }
+  else {
+    /* source was NULL, assign zero, could also remove */
+    dw_dst = defvert_find_index(dvert_dst, defgroup_dst);
+
+    if (dw_dst) {
+      dw_dst->weight = 0.0f;
+    }
+  }
 }
 
 /**
@@ -191,43 +193,49 @@ void defvert_copy_index(
  */
 void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bool use_verify)
 {
-       if (dvert_src->totweight && dvert_dst->totweight) {
-               int i;
-               MDeformWeight *dw_src;
-               for (i = 0, dw_src = dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
-                       MDeformWeight *dw_dst;
-                       if (use_verify) dw_dst = defvert_verify_index(dvert_dst, dw_src->def_nr);
-                       else            dw_dst = defvert_find_index(dvert_dst, dw_src->def_nr);
-
-                       if (dw_dst) {
-                               dw_dst->weight = dw_src->weight;
-                       }
-               }
-       }
+  if (dvert_src->totweight && dvert_dst->totweight) {
+    int i;
+    MDeformWeight *dw_src;
+    for (i = 0, dw_src = dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
+      MDeformWeight *dw_dst;
+      if (use_verify)
+        dw_dst = defvert_verify_index(dvert_dst, dw_src->def_nr);
+      else
+        dw_dst = defvert_find_index(dvert_dst, dw_src->def_nr);
+
+      if (dw_dst) {
+        dw_dst->weight = dw_src->weight;
+      }
+    }
+  }
 }
 
 /**
  * be sure all flip_map values are valid
  */
-void defvert_sync_mapped(
-        MDeformVert *dvert_dst, const MDeformVert *dvert_src,
-        const int *flip_map, const int flip_map_len, const bool use_verify)
+void defvert_sync_mapped(MDeformVert *dvert_dst,
+                         const MDeformVert *dvert_src,
+                         const int *flip_map,
+                         const int flip_map_len,
+                         const bool use_verify)
 {
-       if (dvert_src->totweight && dvert_dst->totweight) {
-               int i;
-               MDeformWeight *dw_src;
-               for (i = 0, dw_src = dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
-                       if (dw_src->def_nr < flip_map_len) {
-                               MDeformWeight *dw_dst;
-                               if (use_verify) dw_dst = defvert_verify_index(dvert_dst, flip_map[dw_src->def_nr]);
-                               else            dw_dst = defvert_find_index(dvert_dst, flip_map[dw_src->def_nr]);
-
-                               if (dw_dst) {
-                                       dw_dst->weight = dw_src->weight;
-                               }
-                       }
-               }
-       }
+  if (dvert_src->totweight && dvert_dst->totweight) {
+    int i;
+    MDeformWeight *dw_src;
+    for (i = 0, dw_src = dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
+      if (dw_src->def_nr < flip_map_len) {
+        MDeformWeight *dw_dst;
+        if (use_verify)
+          dw_dst = defvert_verify_index(dvert_dst, flip_map[dw_src->def_nr]);
+        else
+          dw_dst = defvert_find_index(dvert_dst, flip_map[dw_src->def_nr]);
+
+        if (dw_dst) {
+          dw_dst->weight = dw_src->weight;
+        }
+      }
+    }
+  }
 }
 
 /**
@@ -235,248 +243,252 @@ void defvert_sync_mapped(
  */
 void defvert_remap(MDeformVert *dvert, int *map, const int map_len)
 {
-       MDeformWeight *dw = dvert->dw;
-       unsigned int i;
-       for (i = dvert->totweight; i != 0; i--, dw++) {
-               if (dw->def_nr < map_len) {
-                       dw->def_nr = map[dw->def_nr];
-
-                       /* just in case */
-                       BLI_assert(dw->def_nr >= 0);
-               }
-       }
+  MDeformWeight *dw = dvert->dw;
+  unsigned int i;
+  for (i = dvert->totweight; i != 0; i--, dw++) {
+    if (dw->def_nr < map_len) {
+      dw->def_nr = map[dw->def_nr];
+
+      /* just in case */
+      BLI_assert(dw->def_nr >= 0);
+    }
+  }
 }
 
 /**
  * Same as #defvert_normalize but takes a bool array.
  */
-void defvert_normalize_subset(MDeformVert *dvert,
-                              const bool *vgroup_subset, const int vgroup_tot)
+void defvert_normalize_subset(MDeformVert *dvert, const bool *vgroup_subset, const int vgroup_tot)
 {
-       if (dvert->totweight == 0) {
-               /* nothing */
-       }
-       else if (dvert->totweight == 1) {
-               MDeformWeight *dw = dvert->dw;
-               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                       dw->weight = 1.0f;
-               }
-       }
-       else {
-               MDeformWeight *dw;
-               unsigned int i;
-               float tot_weight = 0.0f;
-
-               for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                       if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                               tot_weight += dw->weight;
-                       }
-               }
-
-               if (tot_weight > 0.0f) {
-                       float scalar = 1.0f / tot_weight;
-                       for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                                       dw->weight *= scalar;
-
-                                       /* in case of division errors with very low weights */
-                                       CLAMP(dw->weight, 0.0f, 1.0f);
-                               }
-                       }
-               }
-       }
+  if (dvert->totweight == 0) {
+    /* nothing */
+  }
+  else if (dvert->totweight == 1) {
+    MDeformWeight *dw = dvert->dw;
+    if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+      dw->weight = 1.0f;
+    }
+  }
+  else {
+    MDeformWeight *dw;
+    unsigned int i;
+    float tot_weight = 0.0f;
+
+    for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+      if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+        tot_weight += dw->weight;
+      }
+    }
+
+    if (tot_weight > 0.0f) {
+      float scalar = 1.0f / tot_weight;
+      for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+        if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+          dw->weight *= scalar;
+
+          /* in case of division errors with very low weights */
+          CLAMP(dw->weight, 0.0f, 1.0f);
+        }
+      }
+    }
+  }
 }
 
 void defvert_normalize(MDeformVert *dvert)
 {
-       if (dvert->totweight == 0) {
-               /* nothing */
-       }
-       else if (dvert->totweight == 1) {
-               dvert->dw[0].weight = 1.0f;
-       }
-       else {
-               MDeformWeight *dw;
-               unsigned int i;
-               float tot_weight = 0.0f;
-
-               for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                       tot_weight += dw->weight;
-               }
-
-               if (tot_weight > 0.0f) {
-                       float scalar = 1.0f / tot_weight;
-                       for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                               dw->weight *= scalar;
-
-                               /* in case of division errors with very low weights */
-                               CLAMP(dw->weight, 0.0f, 1.0f);
-                       }
-               }
-       }
+  if (dvert->totweight == 0) {
+    /* nothing */
+  }
+  else if (dvert->totweight == 1) {
+    dvert->dw[0].weight = 1.0f;
+  }
+  else {
+    MDeformWeight *dw;
+    unsigned int i;
+    float tot_weight = 0.0f;
+
+    for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+      tot_weight += dw->weight;
+    }
+
+    if (tot_weight > 0.0f) {
+      float scalar = 1.0f / tot_weight;
+      for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+        dw->weight *= scalar;
+
+        /* in case of division errors with very low weights */
+        CLAMP(dw->weight, 0.0f, 1.0f);
+      }
+    }
+  }
 }
 
 /**
  * Same as defvert_normalize() if the locked vgroup is not a member of the subset
  */
-void defvert_normalize_lock_single(
-        MDeformVert *dvert,
-        const bool *vgroup_subset, const int vgroup_tot,
-        const int def_nr_lock)
+void defvert_normalize_lock_single(MDeformVert *dvert,
+                                   const bool *vgroup_subset,
+                                   const int vgroup_tot,
+                                   const int def_nr_lock)
 {
-       if (dvert->totweight == 0) {
-               /* nothing */
-       }
-       else if (dvert->totweight == 1) {
-               MDeformWeight *dw = dvert->dw;
-               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                       if (def_nr_lock != 0) {
-                               dw->weight = 1.0f;
-                       }
-               }
-       }
-       else {
-               MDeformWeight *dw_lock = NULL;
-               MDeformWeight *dw;
-               unsigned int i;
-               float tot_weight = 0.0f;
-               float lock_iweight = 1.0f;
-
-               for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                       if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                               if (dw->def_nr != def_nr_lock) {
-                                       tot_weight += dw->weight;
-                               }
-                               else {
-                                       dw_lock = dw;
-                                       lock_iweight = (1.0f - dw_lock->weight);
-                                       CLAMP(lock_iweight, 0.0f, 1.0f);
-                               }
-                       }
-               }
-
-               if (tot_weight > 0.0f) {
-                       /* paranoid, should be 1.0 but in case of float error clamp anyway */
-
-                       float scalar = (1.0f / tot_weight) * lock_iweight;
-                       for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                                       if (dw != dw_lock) {
-                                               dw->weight *= scalar;
-
-                                               /* in case of division errors with very low weights */
-                                               CLAMP(dw->weight, 0.0f, 1.0f);
-                                       }
-                               }
-                       }
-               }
-       }
+  if (dvert->totweight == 0) {
+    /* nothing */
+  }
+  else if (dvert->totweight == 1) {
+    MDeformWeight *dw = dvert->dw;
+    if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+      if (def_nr_lock != 0) {
+        dw->weight = 1.0f;
+      }
+    }
+  }
+  else {
+    MDeformWeight *dw_lock = NULL;
+    MDeformWeight *dw;
+    unsigned int i;
+    float tot_weight = 0.0f;
+    float lock_iweight = 1.0f;
+
+    for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+      if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+        if (dw->def_nr != def_nr_lock) {
+          tot_weight += dw->weight;
+        }
+        else {
+          dw_lock = dw;
+          lock_iweight = (1.0f - dw_lock->weight);
+          CLAMP(lock_iweight, 0.0f, 1.0f);
+        }
+      }
+    }
+
+    if (tot_weight > 0.0f) {
+      /* paranoid, should be 1.0 but in case of float error clamp anyway */
+
+      float scalar = (1.0f / tot_weight) * lock_iweight;
+      for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+        if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+          if (dw != dw_lock) {
+            dw->weight *= scalar;
+
+            /* in case of division errors with very low weights */
+            CLAMP(dw->weight, 0.0f, 1.0f);
+          }
+        }
+      }
+    }
+  }
 }
 
 /**
  * Same as defvert_normalize() if no locked vgroup is a member of the subset
  */
-void defvert_normalize_lock_map(
-        MDeformVert *dvert,
-        const bool *vgroup_subset, const int vgroup_tot,
-        const bool *lock_flags, const int defbase_tot)
+void defvert_normalize_lock_map(MDeformVert *dvert,
+                                const bool *vgroup_subset,
+                                const int vgroup_tot,
+                                const bool *lock_flags,
+                                const int defbase_tot)
 {
-       if (dvert->totweight == 0) {
-               /* nothing */
-       }
-       else if (dvert->totweight == 1) {
-               MDeformWeight *dw = dvert->dw;
-               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                       if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
-                               dw->weight = 1.0f;
-                       }
-               }
-       }
-       else {
-               MDeformWeight *dw;
-               unsigned int i;
-               float tot_weight = 0.0f;
-               float lock_iweight = 0.0f;
-
-               for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                       if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                               if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
-                                       tot_weight += dw->weight;
-                               }
-                               else {
-                                       /* invert after */
-                                       lock_iweight += dw->weight;
-                               }
-                       }
-               }
-
-               lock_iweight = max_ff(0.0f, 1.0f - lock_iweight);
-
-               if (tot_weight > 0.0f) {
-                       /* paranoid, should be 1.0 but in case of float error clamp anyway */
-
-                       float scalar = (1.0f / tot_weight) * lock_iweight;
-                       for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
-                               if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
-                                       if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
-                                               dw->weight *= scalar;
-
-                                               /* in case of division errors with very low weights */
-                                               CLAMP(dw->weight, 0.0f, 1.0f);
-                                       }
-                               }
-                       }
-               }
-       }
+  if (dvert->totweight == 0) {
+    /* nothing */
+  }
+  else if (dvert->totweight == 1) {
+    MDeformWeight *dw = dvert->dw;
+    if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+      if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
+        dw->weight = 1.0f;
+      }
+    }
+  }
+  else {
+    MDeformWeight *dw;
+    unsigned int i;
+    float tot_weight = 0.0f;
+    float lock_iweight = 0.0f;
+
+    for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+      if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+        if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
+          tot_weight += dw->weight;
+        }
+        else {
+          /* invert after */
+          lock_iweight += dw->weight;
+        }
+      }
+    }
+
+    lock_iweight = max_ff(0.0f, 1.0f - lock_iweight);
+
+    if (tot_weight > 0.0f) {
+      /* paranoid, should be 1.0 but in case of float error clamp anyway */
+
+      float scalar = (1.0f / tot_weight) * lock_iweight;
+      for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
+        if ((dw->def_nr < vgroup_tot) && vgroup_subset[dw->def_nr]) {
+          if ((dw->def_nr < defbase_tot) && (lock_flags[dw->def_nr] == false)) {
+            dw->weight *= scalar;
+
+            /* in case of division errors with very low weights */
+            CLAMP(dw->weight, 0.0f, 1.0f);
+          }
+        }
+      }
+    }
+  }
 }
 
 void defvert_flip(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
 {
-       MDeformWeight *dw;
-       int i;
-
-       for (dw = dvert->dw, i = 0; i < dvert->totweight; dw++, i++) {
-               if (dw->def_nr < flip_map_len) {
-                       if (flip_map[dw->def_nr] >= 0) {
-                               dw->def_nr = flip_map[dw->def_nr];
-                       }
-               }
-       }
+  MDeformWeight *dw;
+  int i;
+
+  for (dw = dvert->dw, i = 0; i < dvert->totweight; dw++, i++) {
+    if (dw->def_nr < flip_map_len) {
+      if (flip_map[dw->def_nr] >= 0) {
+        dw->def_nr = flip_map[dw->def_nr];
+      }
+    }
+  }
 }
 
 void defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
 {
-       MDeformWeight *dw, *dw_cpy;
-       float weight;
-       int i, totweight = dvert->totweight;
-
-       /* copy weights */
-       for (dw = dvert->dw, i = 0; i < totweight; dw++, i++) {
-               if (dw->def_nr < flip_map_len) {
-                       if (flip_map[dw->def_nr] >= 0) {
-                               /* error checkers complain of this but we'll never get NULL return */
-                               dw_cpy = defvert_verify_index(dvert, flip_map[dw->def_nr]);
-                               dw = &dvert->dw[i]; /* in case array got realloced */
-
-                               /* distribute weights: if only one of the vertex groups was
-                                * assigned this will halve the weights, otherwise it gets
-                                * evened out. this keeps it proportional to other groups */
-                               weight = 0.5f * (dw_cpy->weight + dw->weight);
-                               dw_cpy->weight = weight;
-                               dw->weight = weight;
-                       }
-               }
-       }
+  MDeformWeight *dw, *dw_cpy;
+  float weight;
+  int i, totweight = dvert->totweight;
+
+  /* copy weights */
+  for (dw = dvert->dw, i = 0; i < totweight; dw++, i++) {
+    if (dw->def_nr < flip_map_len) {
+      if (flip_map[dw->def_nr] >= 0) {
+        /* error checkers complain of this but we'll never get NULL return */
+        dw_cpy = defvert_verify_index(dvert, flip_map[dw->def_nr]);
+        dw = &dvert->dw[i]; /* in case array got realloced */
+
+        /* distribute weights: if only one of the vertex groups was
+         * assigned this will halve the weights, otherwise it gets
+         * evened out. this keeps it proportional to other groups */
+        weight = 0.5f * (dw_cpy->weight + dw->weight);
+        dw_cpy->weight = weight;
+        dw->weight = weight;
+      }
+    }
+  }
 }
 
 bDeformGroup *defgroup_find_name(Object *ob, const char *name)
 {
-       return (name && name[0] != '\0') ? BLI_findstring(&ob->defbase, name, offsetof(bDeformGroup, name)) : NULL;
+  return (name && name[0] != '\0') ?
+             BLI_findstring(&ob->defbase, name, offsetof(bDeformGroup, name)) :
+             NULL;
 }
 
 int defgroup_name_index(Object *ob, const char *name)
 {
-       return (name && name[0] != '\0') ? BLI_findstringindex(&ob->defbase, name, offsetof(bDeformGroup, name)) : -1;
+  return (name && name[0] != '\0') ?
+             BLI_findstringindex(&ob->defbase, name, offsetof(bDeformGroup, name)) :
+             -1;
 }
 
 /**
@@ -484,40 +496,40 @@ int defgroup_name_index(Object *ob, const char *name)
  */
 int *defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
 {
-       int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
-
-       if (defbase_tot == 0) {
-               return NULL;
-       }
-       else {
-               bDeformGroup *dg;
-               char name_flip[sizeof(dg->name)];
-               int i, flip_num, *map = MEM_mallocN(defbase_tot * sizeof(int), __func__);
-
-               for (i = 0; i < defbase_tot; i++) {
-                       map[i] = -1;
-               }
-
-               for (dg = ob->defbase.first, i = 0; dg; dg = dg->next, i++) {
-                       if (map[i] == -1) { /* may be calculated previously */
-
-                               /* in case no valid value is found, use this */
-                               if (use_default)
-                                       map[i] = i;
-
-                               BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
-
-                               if (!STREQ(name_flip, dg->name)) {
-                                       flip_num = defgroup_name_index(ob, name_flip);
-                                       if (flip_num >= 0) {
-                                               map[i] = flip_num;
-                                               map[flip_num] = i; /* save an extra lookup */
-                                       }
-                               }
-                       }
-               }
-               return map;
-       }
+  int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
+
+  if (defbase_tot == 0) {
+    return NULL;
+  }
+  else {
+    bDeformGroup *dg;
+    char name_flip[sizeof(dg->name)];
+    int i, flip_num, *map = MEM_mallocN(defbase_tot * sizeof(int), __func__);
+
+    for (i = 0; i < defbase_tot; i++) {
+      map[i] = -1;
+    }
+
+    for (dg = ob->defbase.first, i = 0; dg; dg = dg->next, i++) {
+      if (map[i] == -1) { /* may be calculated previously */
+
+        /* in case no valid value is found, use this */
+        if (use_default)
+          map[i] = i;
+
+        BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
+
+        if (!STREQ(name_flip, dg->name)) {
+          flip_num = defgroup_name_index(ob, name_flip);
+          if (flip_num >= 0) {
+            map[i] = flip_num;
+            map[flip_num] = i; /* save an extra lookup */
+          }
+        }
+      }
+    }
+    return map;
+  }
 }
 
 /**
@@ -525,87 +537,93 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
  */
 int *defgroup_flip_map_single(Object *ob, int *flip_map_len, const bool use_default, int defgroup)
 {
-       int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
-
-       if (defbase_tot == 0) {
-               return NULL;
-       }
-       else {
-               bDeformGroup *dg;
-               char name_flip[sizeof(dg->name)];
-               int i, flip_num, *map = MEM_mallocN(defbase_tot * sizeof(int), __func__);
-
-               for (i = 0; i < defbase_tot; i++) {
-                       map[i] = use_default ? i : -1;
-               }
-
-               dg = BLI_findlink(&ob->defbase, defgroup);
-
-               BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
-               if (!STREQ(name_flip, dg->name)) {
-                       flip_num = defgroup_name_index(ob, name_flip);
-
-                       if (flip_num != -1) {
-                               map[defgroup] = flip_num;
-                               map[flip_num] = defgroup;
-                       }
-               }
-
-               return map;
-       }
+  int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
+
+  if (defbase_tot == 0) {
+    return NULL;
+  }
+  else {
+    bDeformGroup *dg;
+    char name_flip[sizeof(dg->name)];
+    int i, flip_num, *map = MEM_mallocN(defbase_tot * sizeof(int), __func__);
+
+    for (i = 0; i < defbase_tot; i++) {
+      map[i] = use_default ? i : -1;
+    }
+
+    dg = BLI_findlink(&ob->defbase, defgroup);
+
+    BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
+    if (!STREQ(name_flip, dg->name)) {
+      flip_num = defgroup_name_index(ob, name_flip);
+
+      if (flip_num != -1) {
+        map[defgroup] = flip_num;
+        map[flip_num] = defgroup;
+      }
+    }
+
+    return map;
+  }
 }
 
 int defgroup_flip_index(Object *ob, int index, const bool use_default)
 {
-       bDeformGroup *dg = BLI_findlink(&ob->defbase, index);
-       int flip_index = -1;
+  bDeformGroup *dg = BLI_findlink(&ob->defbase, index);
+  int flip_index = -1;
 
-       if (dg) {
-               char name_flip[sizeof(dg->name)];
-               BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
+  if (dg) {
+    char name_flip[sizeof(dg->name)];
+    BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
 
-               if (!STREQ(name_flip, dg->name)) {
-                       flip_index = defgroup_name_index(ob, name_flip);
-               }
-       }
+    if (!STREQ(name_flip, dg->name)) {
+      flip_index = defgroup_name_index(ob, name_flip);
+    }
+  }
 
-       return (flip_index == -1 && use_default) ? index : flip_index;
+  return (flip_index == -1 && use_default) ? index : flip_index;
 }
 
 static bool defgroup_find_name_dupe(const char *name, bDeformGroup *dg, Object *ob)
 {
-       bDeformGroup *curdef;
+  bDeformGroup *curdef;
 
-       for (curdef = ob->defbase.first; curdef; curdef = curdef->next) {
-               if (dg != curdef) {
-                       if (STREQ(curdef->name, name)) {
-                               return true;
-                       }
-               }
-       }
+  for (curdef = ob->defbase.first; curdef; curdef = curdef->next) {
+    if (dg != curdef) {
+      if (STREQ(curdef->name, name)) {
+        return true;
+      }
+    }
+  }
 
-       return false;
+  return false;
 }
 
 static bool defgroup_unique_check(void *arg, const char *name)
 {
-       struct {Object *ob; void *dg; } *data = arg;
-       return defgroup_find_name_dupe(name, data->dg, data->ob);
+  struct {
+    Object *ob;
+    void *dg;
+  } *data = arg;
+  return defgroup_find_name_dupe(name, data->dg, data->ob);
 }
 
 void defgroup_unique_name(bDeformGroup *dg, Object *ob)
 {
-       struct {Object *ob; void *dg; } data;
-       data.ob = ob;
-       data.dg = dg;
-
-       BLI_uniquename_cb(defgroup_unique_check, &data, DATA_("Group"), '.', dg->name, sizeof(dg->name));
+  struct {
+    Object *ob;
+    void *dg;
+  } data;
+  data.ob = ob;
+  data.dg = dg;
+
+  BLI_uniquename_cb(defgroup_unique_check, &data, DATA_("Group"), '.', dg->name, sizeof(dg->name));
 }
 
 float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
 {
-       MDeformWeight *dw = defvert_find_index(dvert, defgroup);
-       return dw ? dw->weight : 0.0f;
+  MDeformWeight *dw = defvert_find_index(dvert, defgroup);
+  return dw ? dw->weight : 0.0f;
 }
 
 /**
@@ -615,41 +633,42 @@ float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
  *
  * This is a bit confusing, just saves some checks from the caller.
  */
-float defvert_array_find_weight_safe(const struct MDeformVert *dvert, const int index, const int defgroup)
+float defvert_array_find_weight_safe(const struct MDeformVert *dvert,
+                                     const int index,
+                                     const int defgroup)
 {
-       /* Invalid defgroup index means the vgroup selected is invalid, does not exist, in that case it is OK to return 1.0
-        * (i.e. maximum weight, as if no vgroup was selected).
-        * But in case of valid defgroup and NULL dvert data pointer, it means that vgroup **is** valid,
-        * and just totally empty, so we shall return '0.0' value then!
-        */
-       if (defgroup == -1) {
-               return 1.0f;
-       }
-       else if (dvert == NULL) {
-               return 0.0f;
-       }
-
-       return defvert_find_weight(dvert + index, defgroup);
+  /* Invalid defgroup index means the vgroup selected is invalid, does not exist, in that case it is OK to return 1.0
+   * (i.e. maximum weight, as if no vgroup was selected).
+   * But in case of valid defgroup and NULL dvert data pointer, it means that vgroup **is** valid,
+   * and just totally empty, so we shall return '0.0' value then!
+   */
+  if (defgroup == -1) {
+    return 1.0f;
+  }
+  else if (dvert == NULL) {
+    return 0.0f;
+  }
+
+  return defvert_find_weight(dvert + index, defgroup);
 }
 
-
 MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
 {
-       if (dvert && defgroup >= 0) {
-               MDeformWeight *dw = dvert->dw;
-               unsigned int i;
-
-               for (i = dvert->totweight; i != 0; i--, dw++) {
-                       if (dw->def_nr == defgroup) {
-                               return dw;
-                       }
-               }
-       }
-       else {
-               BLI_assert(0);
-       }
-
-       return NULL;
+  if (dvert && defgroup >= 0) {
+    MDeformWeight *dw = dvert->dw;
+    unsigned int i;
+
+    for (i = dvert->totweight; i != 0; i--, dw++) {
+      if (dw->def_nr == defgroup) {
+        return dw;
+      }
+    }
+  }
+  else {
+    BLI_assert(0);
+  }
+
+  return NULL;
 }
 
 /**
@@ -659,32 +678,32 @@ MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
  */
 MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
 {
-       MDeformWeight *dw_new;
-
-       /* do this check always, this function is used to check for it */
-       if (!dvert || defgroup < 0) {
-               BLI_assert(0);
-               return NULL;
-       }
-
-       dw_new = defvert_find_index(dvert, defgroup);
-       if (dw_new)
-               return dw_new;
-
-       dw_new = MEM_mallocN(sizeof(MDeformWeight) * (dvert->totweight + 1), "deformWeight");
-       if (dvert->dw) {
-               memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
-               MEM_freeN(dvert->dw);
-       }
-       dvert->dw = dw_new;
-       dw_new += dvert->totweight;
-       dw_new->weight = 0.0f;
-       dw_new->def_nr = defgroup;
-       /* Group index */
-
-       dvert->totweight++;
-
-       return dw_new;
+  MDeformWeight *dw_new;
+
+  /* do this check always, this function is used to check for it */
+  if (!dvert || defgroup < 0) {
+    BLI_assert(0);
+    return NULL;
+  }
+
+  dw_new = defvert_find_index(dvert, defgroup);
+  if (dw_new)
+    return dw_new;
+
+  dw_new = MEM_mallocN(sizeof(MDeformWeight) * (dvert->totweight + 1), "deformWeight");
+  if (dvert->dw) {
+    memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
+    MEM_freeN(dvert->dw);
+  }
+  dvert->dw = dw_new;
+  dw_new += dvert->totweight;
+  dw_new->weight = 0.0f;
+  dw_new->def_nr = defgroup;
+  /* Group index */
+
+  dvert->totweight++;
+
+  return dw_new;
 }
 
 /* TODO. merge with code above! */
@@ -696,27 +715,27 @@ MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
  */
 void defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weight)
 {
-       MDeformWeight *dw_new;
-
-       /* do this check always, this function is used to check for it */
-       if (!dvert || defgroup < 0) {
-               BLI_assert(0);
-               return;
-       }
-
-       dw_new = MEM_callocN(sizeof(MDeformWeight) * (dvert->totweight + 1), "defvert_add_to group, new deformWeight");
-       if (dvert->dw) {
-               memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
-               MEM_freeN(dvert->dw);
-       }
-       dvert->dw = dw_new;
-       dw_new += dvert->totweight;
-       dw_new->weight = weight;
-       dw_new->def_nr = defgroup;
-       dvert->totweight++;
+  MDeformWeight *dw_new;
+
+  /* do this check always, this function is used to check for it */
+  if (!dvert || defgroup < 0) {
+    BLI_assert(0);
+    return;
+  }
+
+  dw_new = MEM_callocN(sizeof(MDeformWeight) * (dvert->totweight + 1),
+                       "defvert_add_to group, new deformWeight");
+  if (dvert->dw) {
+    memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
+    MEM_freeN(dvert->dw);
+  }
+  dvert->dw = dw_new;
+  dw_new += dvert->totweight;
+  dw_new->weight = weight;
+  dw_new->def_nr = defgroup;
+  dvert->totweight++;
 }
 
-
 /**
  * Removes the given vertex from the vertex group.
  *
@@ -724,43 +743,43 @@ void defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weig
  */
 void defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
 {
-       if (dvert && dw) {
-               int i = dw - dvert->dw;
-
-               /* Security check! */
-               if (i < 0 || i >= dvert->totweight) {
-                       return;
-               }
-
-               dvert->totweight--;
-               /* If there are still other deform weights attached to this vert then remove
-                * this deform weight, and reshuffle the others.
-                */
-               if (dvert->totweight) {
-                       BLI_assert(dvert->dw != NULL);
-
-                       if (i != dvert->totweight) {
-                               dvert->dw[i] = dvert->dw[dvert->totweight];
-                       }
-
-                       dvert->dw = MEM_reallocN(dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
-               }
-               else {
-                       /* If there are no other deform weights left then just remove this one. */
-                       MEM_freeN(dvert->dw);
-                       dvert->dw = NULL;
-               }
-       }
+  if (dvert && dw) {
+    int i = dw - dvert->dw;
+
+    /* Security check! */
+    if (i < 0 || i >= dvert->totweight) {
+      return;
+    }
+
+    dvert->totweight--;
+    /* If there are still other deform weights attached to this vert then remove
+     * this deform weight, and reshuffle the others.
+     */
+    if (dvert->totweight) {
+      BLI_assert(dvert->dw != NULL);
+
+      if (i != dvert->totweight) {
+        dvert->dw[i] = dvert->dw[dvert->totweight];
+      }
+
+      dvert->dw = MEM_reallocN(dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
+    }
+    else {
+      /* If there are no other deform weights left then just remove this one. */
+      MEM_freeN(dvert->dw);
+      dvert->dw = NULL;
+    }
+  }
 }
 
 void defvert_clear(MDeformVert *dvert)
 {
-       if (dvert->dw) {
-               MEM_freeN(dvert->dw);
-               dvert->dw = NULL;
-       }
+  if (dvert->dw) {
+    MEM_freeN(dvert->dw);
+    dvert->dw = NULL;
+  }
 
-       dvert->totweight = 0;
+  dvert->totweight = 0;
 }
 
 /**
@@ -769,18 +788,18 @@ void defvert_clear(MDeformVert *dvert)
  */
 int defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
 {
-       if (dvert_a->totweight && dvert_b->totweight) {
-               MDeformWeight *dw = dvert_a->dw;
-               unsigned int i;
-
-               for (i = dvert_a->totweight; i != 0; i--, dw++) {
-                       if (dw->weight > 0.0f && defvert_find_weight(dvert_b, dw->def_nr) > 0.0f) {
-                               return dw->def_nr;
-                       }
-               }
-       }
-
-       return -1;
+  if (dvert_a->totweight && dvert_b->totweight) {
+    MDeformWeight *dw = dvert_a->dw;
+    unsigned int i;
+
+    for (i = dvert_a->totweight; i != 0; i--, dw++) {
+      if (dw->weight > 0.0f && defvert_find_weight(dvert_b, dw->def_nr) > 0.0f) {
+        return dw->def_nr;
+      }
+    }
+  }
+
+  return -1;
 }
 
 /**
@@ -788,20 +807,19 @@ int defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
  */
 bool defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot)
 {
-       MDeformWeight *dw = dvert->dw;
-       unsigned int i;
-       for (i = dvert->totweight; i != 0; i--, dw++) {
-               if (dw->weight != 0.0f) {
-                       /* check the group is in-range, happens on rare situations */
-                       if (LIKELY(dw->def_nr < defgroup_tot)) {
-                               return false;
-                       }
-               }
-       }
-       return true;
+  MDeformWeight *dw = dvert->dw;
+  unsigned int i;
+  for (i = dvert->totweight; i != 0; i--, dw++) {
+    if (dw->weight != 0.0f) {
+      /* check the group is in-range, happens on rare situations */
+      if (LIKELY(dw->def_nr < defgroup_tot)) {
+        return false;
+      }
+    }
+  }
+  return true;
 }
 
-
 /**
  * \return The representative weight of a multipaint group, used for
  * viewport colors and actual painting.
@@ -810,480 +828,570 @@ bool defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_
  * Value is not clamped, since painting relies on multiplication being always
  * commutative with the collective weight function.
  */
-float BKE_defvert_multipaint_collective_weight(
-        const struct MDeformVert *dv, int defbase_tot,
-        const bool *defbase_sel, int defbase_tot_sel, bool do_autonormalize)
+float BKE_defvert_multipaint_collective_weight(const struct MDeformVert *dv,
+                                               int defbase_tot,
+                                               const bool *defbase_sel,
+                                               int defbase_tot_sel,
+                                               bool do_autonormalize)
 {
-       int i;
-       float total = 0.0f;
-       const MDeformWeight *dw = dv->dw;
-
-       for (i = dv->totweight; i != 0; i--, dw++) {
-               /* in multipaint, get the average if auto normalize is inactive
-                * get the sum if it is active */
-               if (dw->def_nr < defbase_tot) {
-                       if (defbase_sel[dw->def_nr]) {
-                               total += dw->weight;
-                       }
-               }
-       }
-
-       if (do_autonormalize == false) {
-               total /= defbase_tot_sel;
-       }
-
-       return total;
+  int i;
+  float total = 0.0f;
+  const MDeformWeight *dw = dv->dw;
+
+  for (i = dv->totweight; i != 0; i--, dw++) {
+    /* in multipaint, get the average if auto normalize is inactive
+     * get the sum if it is active */
+    if (dw->def_nr < defbase_tot) {
+      if (defbase_sel[dw->def_nr]) {
+        total += dw->weight;
+      }
+    }
+  }
+
+  if (do_autonormalize == false) {
+    total /= defbase_tot_sel;
+  }
+
+  return total;
 }
 
-
 /* -------------------------------------------------------------------- */
 /** \name Defvert Array functions
  * \{ */
 
 void BKE_defvert_array_copy(MDeformVert *dst, const MDeformVert *src, int copycount)
 {
-       /* Assumes dst is already set up */
-       int i;
+  /* Assumes dst is already set up */
+  int i;
 
-       if (!src || !dst)
-               return;
+  if (!src || !dst)
+    return;
 
-       memcpy(dst, src, copycount * sizeof(MDeformVert));
-
-       for (i = 0; i < copycount; i++) {
-               if (src[i].dw) {
-                       dst[i].dw = MEM_mallocN(sizeof(MDeformWeight) * src[i].totweight, "copy_deformWeight");
-                       memcpy(dst[i].dw, src[i].dw, sizeof(MDeformWeight) * src[i].totweight);
-               }
-       }
+  memcpy(dst, src, copycount * sizeof(MDeformVert));
 
+  for (i = 0; i < copycount; i++) {
+    if (src[i].dw) {
+      dst[i].dw = MEM_mallocN(sizeof(MDeformWeight) * src[i].totweight, "copy_deformWeight");
+      memcpy(dst[i].dw, src[i].dw, sizeof(MDeformWeight) * src[i].totweight);
+    }
+  }
 }
 
 void BKE_defvert_array_free_elems(MDeformVert *dvert, int totvert)
 {
-       /* Instead of freeing the verts directly,
-        * call this function to delete any special
-        * vert data */
-       int i;
-
-       if (!dvert)
-               return;
-
-       /* Free any special data from the verts */
-       for (i = 0; i < totvert; i++) {
-               if (dvert[i].dw) MEM_freeN(dvert[i].dw);
-       }
+  /* Instead of freeing the verts directly,
+   * call this function to delete any special
+   * vert data */
+  int i;
+
+  if (!dvert)
+    return;
+
+  /* Free any special data from the verts */
+  for (i = 0; i < totvert; i++) {
+    if (dvert[i].dw)
+      MEM_freeN(dvert[i].dw);
+  }
 }
 
 void BKE_defvert_array_free(MDeformVert *dvert, int totvert)
 {
-       /* Instead of freeing the verts directly,
-        * call this function to delete any special
-        * vert data */
-       if (!dvert)
-               return;
+  /* Instead of freeing the verts directly,
+   * call this function to delete any special
+   * vert data */
+  if (!dvert)
+    return;
 
-       /* Free any special data from the verts */
-       BKE_defvert_array_free_elems(dvert, totvert);
+  /* Free any special data from the verts */
+  BKE_defvert_array_free_elems(dvert, totvert);
 
-       MEM_freeN(dvert);
+  MEM_freeN(dvert);
 }
 
-void BKE_defvert_extract_vgroup_to_vertweights(
-        MDeformVert *dvert, const int defgroup, const int num_verts, float *r_weights, const bool invert_vgroup)
+void BKE_defvert_extract_vgroup_to_vertweights(MDeformVert *dvert,
+                                               const int defgroup,
+                                               const int num_verts,
+                                               float *r_weights,
+                                               const bool invert_vgroup)
 {
-       if (dvert && defgroup != -1) {
-               int i = num_verts;
-
-               while (i--) {
-                       const float w = defvert_find_weight(&dvert[i], defgroup);
-                       r_weights[i] = invert_vgroup ? (1.0f - w) : w;
-               }
-       }
-       else {
-               copy_vn_fl(r_weights, num_verts, invert_vgroup ? 1.0f : 0.0f);
-       }
+  if (dvert && defgroup != -1) {
+    int i = num_verts;
+
+    while (i--) {
+      const float w = defvert_find_weight(&dvert[i], defgroup);
+      r_weights[i] = invert_vgroup ? (1.0f - w) : w;
+    }
+  }
+  else {
+    copy_vn_fl(r_weights, num_verts, invert_vgroup ? 1.0f : 0.0f);
+  }
 }
 
 /**
  * The following three make basic interpolation,
  * using temp vert_weights array to avoid looking up same weight several times.
  */
-void BKE_defvert_extract_vgroup_to_edgeweights(
-        MDeformVert *dvert, const int defgroup, const int num_verts, MEdge *edges, const int num_edges,
-        float *r_weights, const bool invert_vgroup)
+void BKE_defvert_extract_vgroup_to_edgeweights(MDeformVert *dvert,
+                                               const int defgroup,
+                                               const int num_verts,
+                                               MEdge *edges,
+                                               const int num_edges,
+                                               float *r_weights,
+                                               const bool invert_vgroup)
 {
-       if (dvert && defgroup != -1) {
-               int i = num_edges;
-               float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
+  if (dvert && defgroup != -1) {
+    int i = num_edges;
+    float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
 
-               BKE_defvert_extract_vgroup_to_vertweights(dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
+    BKE_defvert_extract_vgroup_to_vertweights(
+        dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
 
-               while (i--) {
-                       MEdge *me = &edges[i];
+    while (i--) {
+      MEdge *me = &edges[i];
 
-                       r_weights[i] = (tmp_weights[me->v1] + tmp_weights[me->v2]) * 0.5f;
-               }
+      r_weights[i] = (tmp_weights[me->v1] + tmp_weights[me->v2]) * 0.5f;
+    }
 
-               MEM_freeN(tmp_weights);
-       }
-       else {
-               copy_vn_fl(r_weights, num_edges, 0.0f);
-       }
+    MEM_freeN(tmp_weights);
+  }
+  else {
+    copy_vn_fl(r_weights, num_edges, 0.0f);
+  }
 }
 
-void BKE_defvert_extract_vgroup_to_loopweights(
-        MDeformVert *dvert, const int defgroup, const int num_verts, MLoop *loops, const int num_loops,
-        float *r_weights, const bool invert_vgroup)
+void BKE_defvert_extract_vgroup_to_loopweights(MDeformVert *dvert,
+                                               const int defgroup,
+                                               const int num_verts,
+                                               MLoop *loops,
+                                               const int num_loops,
+                                               float *r_weights,
+                                               const bool invert_vgroup)
 {
-       if (dvert && defgroup != -1) {
-               int i = num_loops;
-               float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
+  if (dvert && defgroup != -1) {
+    int i = num_loops;
+    float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
 
-               BKE_defvert_extract_vgroup_to_vertweights(dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
+    BKE_defvert_extract_vgroup_to_vertweights(
+        dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
 
-               while (i--) {
-                       MLoop *ml = &loops[i];
+    while (i--) {
+      MLoop *ml = &loops[i];
 
-                       r_weights[i] = tmp_weights[ml->v];
-               }
+      r_weights[i] = tmp_weights[ml->v];
+    }
 
-               MEM_freeN(tmp_weights);
-       }
-       else {
-               copy_vn_fl(r_weights, num_loops, 0.0f);
-       }
+    MEM_freeN(tmp_weights);
+  }
+  else {
+    copy_vn_fl(r_weights, num_loops, 0.0f);
+  }
 }
 
-void BKE_defvert_extract_vgroup_to_polyweights(
-        MDeformVert *dvert, const int defgroup, const int num_verts, MLoop *loops, const int UNUSED(num_loops),
-        MPoly *polys, const int num_polys, float *r_weights, const bool invert_vgroup)
+void BKE_defvert_extract_vgroup_to_polyweights(MDeformVert *dvert,
+                                               const int defgroup,
+                                               const int num_verts,
+                                               MLoop *loops,
+                                               const int UNUSED(num_loops),
+                                               MPoly *polys,
+                                               const int num_polys,
+                                               float *r_weights,
+                                               const bool invert_vgroup)
 {
-       if (dvert && defgroup != -1) {
-               int i = num_polys;
-               float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
-
-               BKE_defvert_extract_vgroup_to_vertweights(dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
-
-               while (i--) {
-                       MPoly *mp = &polys[i];
-                       MLoop *ml = &loops[mp->loopstart];
-                       int j = mp->totloop;
-                       float w = 0.0f;
-
-                       for (; j--; ml++) {
-                               w += tmp_weights[ml->v];
-                       }
-                       r_weights[i] = w / (float)mp->totloop;
-               }
-
-               MEM_freeN(tmp_weights);
-       }
-       else {
-               copy_vn_fl(r_weights, num_polys, 0.0f);
-       }
+  if (dvert && defgroup != -1) {
+    int i = num_polys;
+    float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)num_verts, __func__);
+
+    BKE_defvert_extract_vgroup_to_vertweights(
+        dvert, defgroup, num_verts, tmp_weights, invert_vgroup);
+
+    while (i--) {
+      MPoly *mp = &polys[i];
+      MLoop *ml = &loops[mp->loopstart];
+      int j = mp->totloop;
+      float w = 0.0f;
+
+      for (; j--; ml++) {
+        w += tmp_weights[ml->v];
+      }
+      r_weights[i] = w / (float)mp->totloop;
+    }
+
+    MEM_freeN(tmp_weights);
+  }
+  else {
+    copy_vn_fl(r_weights, num_polys, 0.0f);
+  }
 }
 
 /** \} */
 
-
 /* -------------------------------------------------------------------- */
 /** \name Data Transfer
  * \{ */
 
-static void vgroups_datatransfer_interp(
-        const CustomDataTransferLayerMap *laymap, void *dest,
-        const void **sources, const float *weights, const int count, const float mix_factor)
+static void vgroups_datatransfer_interp(const CustomDataTransferLayerMap *laymap,
+                                        void *dest,
+                                        const void **sources,
+                                        const float *weights,
+                                        const int count,
+                                        const float mix_factor)
 {
-       MDeformVert **data_src = (MDeformVert **)sources;
-       MDeformVert *data_dst = (MDeformVert *)dest;
-       const int idx_src = laymap->data_src_n;
-       const int idx_dst = laymap->data_dst_n;
-
-       const int mix_mode = laymap->mix_mode;
-
-       int i, j;
-
-       MDeformWeight *dw_src;
-       MDeformWeight *dw_dst = defvert_find_index(data_dst, idx_dst);
-       float weight_src = 0.0f, weight_dst = 0.0f;
-
-       if (sources) {
-               for (i = count; i--;) {
-                       for (j = data_src[i]->totweight; j--;) {
-                               if ((dw_src = &data_src[i]->dw[j])->def_nr == idx_src) {
-                                       weight_src += dw_src->weight * weights[i];
-                                       break;
-                               }
-                       }
-               }
-       }
-
-       if (dw_dst) {
-               weight_dst = dw_dst->weight;
-       }
-       else if (mix_mode == CDT_MIX_REPLACE_ABOVE_THRESHOLD) {
-               return;  /* Do not affect destination. */
-       }
-
-       weight_src = data_transfer_interp_float_do(mix_mode, weight_dst, weight_src, mix_factor);
-
-       CLAMP(weight_src, 0.0f, 1.0f);
-
-       if (!dw_dst) {
-               defvert_add_index_notest(data_dst, idx_dst, weight_src);
-       }
-       else {
-               dw_dst->weight = weight_src;
-       }
+  MDeformVert **data_src = (MDeformVert **)sources;
+  MDeformVert *data_dst = (MDeformVert *)dest;
+  const int idx_src = laymap->data_src_n;
+  const int idx_dst = laymap->data_dst_n;
+
+  const int mix_mode = laymap->mix_mode;
+
+  int i, j;
+
+  MDeformWeight *dw_src;
+  MDeformWeight *dw_dst = defvert_find_index(data_dst, idx_dst);
+  float weight_src = 0.0f, weight_dst = 0.0f;
+
+  if (sources) {
+    for (i = count; i--;) {
+      for (j = data_src[i]->totweight; j--;) {
+        if ((dw_src = &data_src[i]->dw[j])->def_nr == idx_src) {
+          weight_src += dw_src->weight * weights[i];
+          break;
+        }
+      }
+    }
+  }
+
+  if (dw_dst) {
+    weight_dst = dw_dst->weight;
+  }
+  else if (mix_mode == CDT_MIX_REPLACE_ABOVE_THRESHOLD) {
+    return; /* Do not affect destination. */
+  }
+
+  weight_src = data_transfer_interp_float_do(mix_mode, weight_dst, weight_src, mix_factor);
+
+  CLAMP(weight_src, 0.0f, 1.0f);
+
+  if (!dw_dst) {
+    defvert_add_index_notest(data_dst, idx_dst, weight_src);
+  }
+  else {
+    dw_dst->weight = weight_src;
+  }
 }
 
-static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(
-        ListBase *r_map, const int mix_mode, const float mix_factor, const float *mix_weights,
-        const int num_elem_dst, const bool use_create, const bool use_delete,
-        Object *ob_src, Object *ob_dst, MDeformVert *data_src, MDeformVert *data_dst,
-        CustomData *UNUSED(cd_src), CustomData *cd_dst, const bool UNUSED(use_dupref_dst),
-        const int tolayers, bool *use_layers_src, const int num_layers_src)
+static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
+                                                                const int mix_mode,
+                                                                const float mix_factor,
+                                                                const float *mix_weights,
+                                                                const int num_elem_dst,
+                                                                const bool use_create,
+                                                                const bool use_delete,
+                                                                Object *ob_src,
+                                                                Object *ob_dst,
+                                                                MDeformVert *data_src,
+                                                                MDeformVert *data_dst,
+                                                                CustomData *UNUSED(cd_src),
+                                                                CustomData *cd_dst,
+                                                                const bool UNUSED(use_dupref_dst),
+                                                                const int tolayers,
+                                                                bool *use_layers_src,
+                                                                const int num_layers_src)
 {
-       int idx_src;
-       int idx_dst;
-       int tot_dst = BLI_listbase_count(&ob_dst->defbase);
-
-       const size_t elem_size = sizeof(*((MDeformVert *)NULL));
-
-       switch (tolayers) {
-               case DT_LAYERS_INDEX_DST:
-                       idx_dst = tot_dst;
-
-                       /* Find last source actually used! */
-                       idx_src = num_layers_src;
-                       while (idx_src-- && !use_layers_src[idx_src]);
-                       idx_src++;
-
-                       if (idx_dst < idx_src) {
-                               if (use_create) {
-                                       /* Create as much vgroups as necessary! */
-                                       for (; idx_dst < idx_src; idx_dst++) {
-                                               BKE_object_defgroup_add(ob_dst);
-                                       }
-                               }
-                               else {
-                                       /* Otherwise, just try to map what we can with existing dst vgroups. */
-                                       idx_src = idx_dst;
-                               }
-                       }
-                       else if (use_delete && idx_dst > idx_src) {
-                               while (idx_dst-- > idx_src) {
-                                       BKE_object_defgroup_remove(ob_dst, ob_dst->defbase.last);
-                               }
-                       }
-                       if (r_map) {
-                               /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
-                                * Again, use_create is not relevant in this case */
-                               if (!data_dst) {
-                                       data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
-                               }
-
-                               while (idx_src--) {
-                                       if (!use_layers_src[idx_src]) {
-                                               continue;
-                                       }
-                                       data_transfer_layersmapping_add_item(r_map, CD_FAKE_MDEFORMVERT, mix_mode, mix_factor, mix_weights,
-                                                                            data_src, data_dst, idx_src, idx_src,
-                                                                            elem_size, 0, 0, 0, vgroups_datatransfer_interp, NULL);
-                               }
-                       }
-                       break;
-               case DT_LAYERS_NAME_DST:
-                       {
-                               bDeformGroup *dg_src, *dg_dst;
-
-                               if (use_delete) {
-                                       /* Remove all unused dst vgroups first, simpler in this case. */
-                                       for (dg_dst = ob_dst->defbase.first; dg_dst;) {
-                                               bDeformGroup *dg_dst_next = dg_dst->next;
-
-                                               if (defgroup_name_index(ob_src, dg_dst->name) == -1) {
-                                                       BKE_object_defgroup_remove(ob_dst, dg_dst);
-                                               }
-                                               dg_dst = dg_dst_next;
-                                       }
-                               }
-
-                               for (idx_src = 0, dg_src = ob_src->defbase.first;
-                                    idx_src < num_layers_src;
-                                    idx_src++, dg_src = dg_src->next)
-                               {
-                                       if (!use_layers_src[idx_src]) {
-                                               continue;
-                                       }
-
-                                       if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
-                                               if (use_create) {
-                                                       BKE_object_defgroup_add_name(ob_dst, dg_src->name);
-                                                       idx_dst = ob_dst->actdef - 1;
-                                               }
-                                               else {
-                                                       /* If we are not allowed to create missing dst vgroups, just skip matching src one. */
-                                                       continue;
-                                               }
-                                       }
-                                       if (r_map) {
-                                               /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
-                                                * use_create is not relevant in this case */
-                                               if (!data_dst) {
-                                                       data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
-                                               }
-
-                                               data_transfer_layersmapping_add_item(
-                                                       r_map, CD_FAKE_MDEFORMVERT, mix_mode, mix_factor, mix_weights,
-                                                       data_src, data_dst, idx_src, idx_dst,
-                                                       elem_size, 0, 0, 0, vgroups_datatransfer_interp, NULL);
-                                       }
-                               }
-                               break;
-                       }
-               default:
-                       return false;
-       }
-
-       return true;
+  int idx_src;
+  int idx_dst;
+  int tot_dst = BLI_listbase_count(&ob_dst->defbase);
+
+  const size_t elem_size = sizeof(*((MDeformVert *)NULL));
+
+  switch (tolayers) {
+    case DT_LAYERS_INDEX_DST:
+      idx_dst = tot_dst;
+
+      /* Find last source actually used! */
+      idx_src = num_layers_src;
+      while (idx_src-- && !use_layers_src[idx_src])
+        ;
+      idx_src++;
+
+      if (idx_dst < idx_src) {
+        if (use_create) {
+          /* Create as much vgroups as necessary! */
+          for (; idx_dst < idx_src; idx_dst++) {
+            BKE_object_defgroup_add(ob_dst);
+          }
+        }
+        else {
+          /* Otherwise, just try to map what we can with existing dst vgroups. */
+          idx_src = idx_dst;
+        }
+      }
+      else if (use_delete && idx_dst > idx_src) {
+        while (idx_dst-- > idx_src) {
+          BKE_object_defgroup_remove(ob_dst, ob_dst->defbase.last);
+        }
+      }
+      if (r_map) {
+        /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
+         * Again, use_create is not relevant in this case */
+        if (!data_dst) {
+          data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
+        }
+
+        while (idx_src--) {
+          if (!use_layers_src[idx_src]) {
+            continue;
+          }
+          data_transfer_layersmapping_add_item(r_map,
+                                               CD_FAKE_MDEFORMVERT,
+                                               mix_mode,
+                                               mix_factor,
+                                               mix_weights,
+                                               data_src,
+                                               data_dst,
+                                               idx_src,
+                                               idx_src,
+                                               elem_size,
+                                               0,
+                                               0,
+                                               0,
+                                               vgroups_datatransfer_interp,
+                                               NULL);
+        }
+      }
+      break;
+    case DT_LAYERS_NAME_DST: {
+      bDeformGroup *dg_src, *dg_dst;
+
+      if (use_delete) {
+        /* Remove all unused dst vgroups first, simpler in this case. */
+        for (dg_dst = ob_dst->defbase.first; dg_dst;) {
+          bDeformGroup *dg_dst_next = dg_dst->next;
+
+          if (defgroup_name_index(ob_src, dg_dst->name) == -1) {
+            BKE_object_defgroup_remove(ob_dst, dg_dst);
+          }
+          dg_dst = dg_dst_next;
+        }
+      }
+
+      for (idx_src = 0, dg_src = ob_src->defbase.first; idx_src < num_layers_src;
+           idx_src++, dg_src = dg_src->next) {
+        if (!use_layers_src[idx_src]) {
+          continue;
+        }
+
+        if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
+          if (use_create) {
+            BKE_object_defgroup_add_name(ob_dst, dg_src->name);
+            idx_dst = ob_dst->actdef - 1;
+          }
+          else {
+            /* If we are not allowed to create missing dst vgroups, just skip matching src one. */
+            continue;
+          }
+        }
+        if (r_map) {
+          /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
+             * use_create is not relevant in this case */
+          if (!data_dst) {
+            data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
+          }
+
+          data_transfer_layersmapping_add_item(r_map,
+                                               CD_FAKE_MDEFORMVERT,
+                                               mix_mode,
+                                               mix_factor,
+                                               mix_weights,
+                                               data_src,
+                                               data_dst,
+                                               idx_src,
+                                               idx_dst,
+                                               elem_size,
+                                               0,
+                                               0,
+                                               0,
+                                               vgroups_datatransfer_interp,
+                                               NULL);
+        }
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+
+  return true;
 }
 
-bool data_transfer_layersmapping_vgroups(
-        ListBase *r_map, const int mix_mode, const float mix_factor, const float *mix_weights,
-        const int num_elem_dst, const bool use_create, const bool use_delete, Object *ob_src, Object *ob_dst,
-        CustomData *cd_src, CustomData *cd_dst, const bool use_dupref_dst, const int fromlayers, const int tolayers)
+bool data_transfer_layersmapping_vgroups(ListBase *r_map,
+                                         const int mix_mode,
+                                         const float mix_factor,
+                                         const float *mix_weights,
+                                         const int num_elem_dst,
+                                         const bool use_create,
+                                         const bool use_delete,
+                                         Object *ob_src,
+                                         Object *ob_dst,
+                                         CustomData *cd_src,
+                                         CustomData *cd_dst,
+                                         const bool use_dupref_dst,
+                                         const int fromlayers,
+                                         const int tolayers)
 {
-       int idx_src, idx_dst;
-       MDeformVert *data_src, *data_dst = NULL;
-
-       const size_t elem_size = sizeof(*((MDeformVert *)NULL));
-
-       /* Note: VGroups are a bit hairy, since their layout is defined on object level (ob->defbase), while their actual
-        *       data is a (mesh) CD layer.
-        *       This implies we may have to handle data layout itself while having NULL data itself,
-        *       and even have to support NULL data_src in transfer data code (we always create a data_dst, though).
-        */
-
-       if (BLI_listbase_is_empty(&ob_src->defbase)) {
-               if (use_delete) {
-                       BKE_object_defgroup_remove_all(ob_dst);
-               }
-               return true;
-       }
-
-       data_src = CustomData_get_layer(cd_src, CD_MDEFORMVERT);
-
-       data_dst = CustomData_get_layer(cd_dst, CD_MDEFORMVERT);
-       if (data_dst && use_dupref_dst && r_map) {
-               /* If dest is a derivedmesh, we do not want to overwrite cdlayers of org mesh! */
-               data_dst = CustomData_duplicate_referenced_layer(cd_dst, CD_MDEFORMVERT, num_elem_dst);
-       }
-
-       if (fromlayers == DT_LAYERS_ACTIVE_SRC || fromlayers >= 0) {
-               /* Note: use_delete has not much meaning in this case, ignored. */
-
-               if (fromlayers >= 0) {
-                       idx_src = fromlayers;
-                       if (idx_src >= BLI_listbase_count(&ob_src->defbase)) {
-                               /* This can happen when vgroups are removed from source object...
-                                * Remapping would be really tricky here, we'd need to go over all objects in
-                                * Main every time we delete a vgroup... for now, simpler and safer to abort. */
-                               return false;
-                       }
-               }
-               else if ((idx_src = ob_src->actdef - 1) == -1) {
-                       return false;
-               }
-
-               if (tolayers >= 0) {
-                       /* Note: in this case we assume layer exists! */
-                       idx_dst = tolayers;
-                       BLI_assert(idx_dst < BLI_listbase_count(&ob_dst->defbase));
-               }
-               else if (tolayers == DT_LAYERS_ACTIVE_DST) {
-                       if ((idx_dst = ob_dst->actdef - 1) == -1) {
-                               bDeformGroup *dg_src;
-                               if (!use_create) {
-                                       return true;
-                               }
-                               dg_src = BLI_findlink(&ob_src->defbase, idx_src);
-                               BKE_object_defgroup_add_name(ob_dst, dg_src->name);
-                               idx_dst = ob_dst->actdef - 1;
-                       }
-               }
-               else if (tolayers == DT_LAYERS_INDEX_DST) {
-                       int num = BLI_listbase_count(&ob_src->defbase);
-                       idx_dst = idx_src;
-                       if (num <= idx_dst) {
-                               if (!use_create) {
-                                       return true;
-                               }
-                               /* Create as much vgroups as necessary! */
-                               for (; num <= idx_dst; num++) {
-                                       BKE_object_defgroup_add(ob_dst);
-                               }
-                       }
-               }
-               else if (tolayers == DT_LAYERS_NAME_DST) {
-                       bDeformGroup *dg_src = BLI_findlink(&ob_src->defbase, idx_src);
-                       if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
-                               if (!use_create) {
-                                       return true;
-                               }
-                               BKE_object_defgroup_add_name(ob_dst, dg_src->name);
-                               idx_dst = ob_dst->actdef - 1;
-                       }
-               }
-               else {
-                       return false;
-               }
-
-               if (r_map) {
-                       /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
-                        * use_create is not relevant in this case */
-                       if (!data_dst) {
-                               data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
-                       }
-
-                       data_transfer_layersmapping_add_item(r_map, CD_FAKE_MDEFORMVERT, mix_mode, mix_factor, mix_weights,
-                                                            data_src, data_dst, idx_src, idx_dst,
-                                                            elem_size, 0, 0, 0, vgroups_datatransfer_interp, NULL);
-               }
-       }
-       else {
-               int num_src, num_sel_unused;
-               bool *use_layers_src = NULL;
-               bool ret = false;
-
-               switch (fromlayers) {
-                       case DT_LAYERS_ALL_SRC:
-                               use_layers_src = BKE_object_defgroup_subset_from_select_type(ob_src, WT_VGROUP_ALL,
-                                                                                            &num_src, &num_sel_unused);
-                               break;
-                       case DT_LAYERS_VGROUP_SRC_BONE_SELECT:
-                               use_layers_src = BKE_object_defgroup_subset_from_select_type(ob_src, WT_VGROUP_BONE_SELECT,
-                                                                                            &num_src, &num_sel_unused);
-                               break;
-                       case DT_LAYERS_VGROUP_SRC_BONE_DEFORM:
-                               use_layers_src = BKE_object_defgroup_subset_from_select_type(ob_src, WT_VGROUP_BONE_DEFORM,
-                                                                                            &num_src, &num_sel_unused);
-                               break;
-               }
-
-               if (use_layers_src) {
-                       ret = data_transfer_layersmapping_vgroups_multisrc_to_dst(
-                               r_map, mix_mode, mix_factor, mix_weights, num_elem_dst, use_create, use_delete,
-                               ob_src, ob_dst, data_src, data_dst, cd_src, cd_dst, use_dupref_dst,
-                               tolayers, use_layers_src, num_src);
-               }
-
-               MEM_SAFE_FREE(use_layers_src);
-               return ret;
-       }
-
-       return true;
+  int idx_src, idx_dst;
+  MDeformVert *data_src, *data_dst = NULL;
+
+  const size_t elem_size = sizeof(*((MDeformVert *)NULL));
+
+  /* Note: VGroups are a bit hairy, since their layout is defined on object level (ob->defbase), while their actual
+   *       data is a (mesh) CD layer.
+   *       This implies we may have to handle data layout itself while having NULL data itself,
+   *       and even have to support NULL data_src in transfer data code (we always create a data_dst, though).
+   */
+
+  if (BLI_listbase_is_empty(&ob_src->defbase)) {
+    if (use_delete) {
+      BKE_object_defgroup_remove_all(ob_dst);
+    }
+    return true;
+  }
+
+  data_src = CustomData_get_layer(cd_src, CD_MDEFORMVERT);
+
+  data_dst = CustomData_get_layer(cd_dst, CD_MDEFORMVERT);
+  if (data_dst && use_dupref_dst && r_map) {
+    /* If dest is a derivedmesh, we do not want to overwrite cdlayers of org mesh! */
+    data_dst = CustomData_duplicate_referenced_layer(cd_dst, CD_MDEFORMVERT, num_elem_dst);
+  }
+
+  if (fromlayers == DT_LAYERS_ACTIVE_SRC || fromlayers >= 0) {
+    /* Note: use_delete has not much meaning in this case, ignored. */
+
+    if (fromlayers >= 0) {
+      idx_src = fromlayers;
+      if (idx_src >= BLI_listbase_count(&ob_src->defbase)) {
+        /* This can happen when vgroups are removed from source object...
+         * Remapping would be really tricky here, we'd need to go over all objects in
+         * Main every time we delete a vgroup... for now, simpler and safer to abort. */
+        return false;
+      }
+    }
+    else if ((idx_src = ob_src->actdef - 1) == -1) {
+      return false;
+    }
+
+    if (tolayers >= 0) {
+      /* Note: in this case we assume layer exists! */
+      idx_dst = tolayers;
+      BLI_assert(idx_dst < BLI_listbase_count(&ob_dst->defbase));
+    }
+    else if (tolayers == DT_LAYERS_ACTIVE_DST) {
+      if ((idx_dst = ob_dst->actdef - 1) == -1) {
+        bDeformGroup *dg_src;
+        if (!use_create) {
+          return true;
+        }
+        dg_src = BLI_findlink(&ob_src->defbase, idx_src);
+        BKE_object_defgroup_add_name(ob_dst, dg_src->name);
+        idx_dst = ob_dst->actdef - 1;
+      }
+    }
+    else if (tolayers == DT_LAYERS_INDEX_DST) {
+      int num = BLI_listbase_count(&ob_src->defbase);
+      idx_dst = idx_src;
+      if (num <= idx_dst) {
+        if (!use_create) {
+          return true;
+        }
+        /* Create as much vgroups as necessary! */
+        for (; num <= idx_dst; num++) {
+          BKE_object_defgroup_add(ob_dst);
+        }
+      }
+    }
+    else if (tolayers == DT_LAYERS_NAME_DST) {
+      bDeformGroup *dg_src = BLI_findlink(&ob_src->defbase, idx_src);
+      if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
+        if (!use_create) {
+          return true;
+        }
+        BKE_object_defgroup_add_name(ob_dst, dg_src->name);
+        idx_dst = ob_dst->actdef - 1;
+      }
+    }
+    else {
+      return false;
+    }
+
+    if (r_map) {
+      /* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
+       * use_create is not relevant in this case */
+      if (!data_dst) {
+        data_dst = CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_CALLOC, NULL, num_elem_dst);
+      }
+
+      data_transfer_layersmapping_add_item(r_map,
+                                           CD_FAKE_MDEFORMVERT,
+                                           mix_mode,
+                                           mix_factor,
+                                           mix_weights,
+                                           data_src,
+                                           data_dst,
+                                           idx_src,
+                                           idx_dst,
+                                           elem_size,
+                                           0,
+                                           0,
+                                           0,
+                                           vgroups_datatransfer_interp,
+                                           NULL);
+    }
+  }
+  else {
+    int num_src, num_sel_unused;
+    bool *use_layers_src = NULL;
+    bool ret = false;
+
+    switch (fromlayers) {
+      case DT_LAYERS_ALL_SRC:
+        use_layers_src = BKE_object_defgroup_subset_from_select_type(
+            ob_src, WT_VGROUP_ALL, &num_src, &num_sel_unused);
+        break;
+      case DT_LAYERS_VGROUP_SRC_BONE_SELECT:
+        use_layers_src = BKE_object_defgroup_subset_from_select_type(
+            ob_src, WT_VGROUP_BONE_SELECT, &num_src, &num_sel_unused);
+        break;
+      case DT_LAYERS_VGROUP_SRC_BONE_DEFORM:
+        use_layers_src = BKE_object_defgroup_subset_from_select_type(
+            ob_src, WT_VGROUP_BONE_DEFORM, &num_src, &num_sel_unused);
+        break;
+    }
+
+    if (use_layers_src) {
+      ret = data_transfer_layersmapping_vgroups_multisrc_to_dst(r_map,
+                                                                mix_mode,
+                                                                mix_factor,
+                                                                mix_weights,
+                                                                num_elem_dst,
+                                                                use_create,
+                                                                use_delete,
+                                                                ob_src,
+                                                                ob_dst,
+                                                                data_src,
+                                                                data_dst,
+                                                                cd_src,
+                                                                cd_dst,
+                                                                use_dupref_dst,
+                                                                tolayers,
+                                                                use_layers_src,
+                                                                num_src);
+    }
+
+    MEM_SAFE_FREE(use_layers_src);
+    return ret;
+  }
+
+  return true;
 }
 
 /** \} */
@@ -1294,35 +1402,35 @@ bool data_transfer_layersmapping_vgroups(
 
 void BKE_defvert_weight_to_rgb(float r_rgb[3], const float weight)
 {
-       const float blend = ((weight / 2.0f) + 0.5f);
-
-       if (weight <= 0.25f) {    /* blue->cyan */
-               r_rgb[0] = 0.0f;
-               r_rgb[1] = blend * weight * 4.0f;
-               r_rgb[2] = blend;
-       }
-       else if (weight <= 0.50f) {  /* cyan->green */
-               r_rgb[0] = 0.0f;
-               r_rgb[1] = blend;
-               r_rgb[2] = blend * (1.0f - ((weight - 0.25f) * 4.0f));
-       }
-       else if (weight <= 0.75f) {  /* green->yellow */
-               r_rgb[0] = blend * ((weight - 0.50f) * 4.0f);
-               r_rgb[1] = blend;
-               r_rgb[2] = 0.0f;
-       }
-       else if (weight <= 1.0f) {  /* yellow->red */
-               r_rgb[0] = blend;
-               r_rgb[1] = blend * (1.0f - ((weight - 0.75f) * 4.0f));
-               r_rgb[2] = 0.0f;
-       }
-       else {
-               /* exceptional value, unclamped or nan,
-                * avoid uninitialized memory use */
-               r_rgb[0] = 1.0f;
-               r_rgb[1] = 0.0f;
-               r_rgb[2] = 1.0f;
-       }
+  const float blend = ((weight / 2.0f) + 0.5f);
+
+  if (weight <= 0.25f) { /* blue->cyan */
+    r_rgb[0] = 0.0f;
+    r_rgb[1] = blend * weight * 4.0f;
+    r_rgb[2] = blend;
+  }
+  else if (weight <= 0.50f) { /* cyan->green */
+    r_rgb[0] = 0.0f;
+    r_rgb[1] = blend;
+    r_rgb[2] = blend * (1.0f - ((weight - 0.25f) * 4.0f));
+  }
+  else if (weight <= 0.75f) { /* green->yellow */
+    r_rgb[0] = blend * ((weight - 0.50f) * 4.0f);
+    r_rgb[1] = blend;
+    r_rgb[2] = 0.0f;
+  }
+  else if (weight <= 1.0f) { /* yellow->red */
+    r_rgb[0] = blend;
+    r_rgb[1] = blend * (1.0f - ((weight - 0.75f) * 4.0f));
+    r_rgb[2] = 0.0f;
+  }
+  else {
+    /* exceptional value, unclamped or nan,
+     * avoid uninitialized memory use */
+    r_rgb[0] = 1.0f;
+    r_rgb[1] = 0.0f;
+    r_rgb[2] = 1.0f;
+  }
 }
 
 /** \} */