use consistent naming for deform.c, also moved defvert_remove_index into deform.c, was local in modifier code.

3 files changed, 157 insertions, 153 deletions

diff --git a/source/blender/blenkernel/BKE_deform.h b/source/blender/blenkernel/BKE_deform.h
index 2dcafd769d8..ed8ea691134 100644
--- a/source/blender/blenkernel/BKE_deform.h
+++ b/source/blender/blenkernel/BKE_deform.h
@@ -52,14 +52,16 @@ void				 defgroup_unique_name(struct bDeformGroup *dg, struct Object *ob);
 
 struct MDeformWeight	*defvert_find_index(const struct MDeformVert *dv, const int defgroup);
 struct MDeformWeight	*defvert_verify_index(struct MDeformVert *dv, const int defgroup);
+void                     defvert_remove_index(struct MDeformVert *dvert, int defgroup, struct MDeformWeight *dw);
 
-float  defvert_find_weight(const struct MDeformVert *dvert, const int group_num);
-float  defvert_array_find_weight_safe(const struct MDeformVert *dvert, int index, int group_num);
+float  defvert_find_weight(const struct MDeformVert *dvert, const int defgroup);
+float  defvert_array_find_weight_safe(const struct MDeformVert *dvert, const int index, const int defgroup);
 
-void defvert_copy(struct MDeformVert *dvert_r, const struct MDeformVert *dvert);
-void defvert_copy_index(struct MDeformVert *dv_dst, const struct MDeformVert *dv_src, const int defgroup);
-void defvert_sync(struct MDeformVert *dvert_r, const struct MDeformVert *dvert, int use_verify);
-void defvert_sync_mapped(struct MDeformVert *dvert_r, const struct MDeformVert *dvert, const int *flip_map, const int flip_map_len, const int use_verify);
+void defvert_copy(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src);
+void defvert_copy_index(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src, const int defgroup);
+void defvert_sync(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src, int use_verify);
+void defvert_sync_mapped(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src,
+                         const int *flip_map, const int flip_map_len, const int use_verify);
 void defvert_remap (struct MDeformVert *dvert, int *map);
 void defvert_flip(struct MDeformVert *dvert, const int *flip_map, const int flip_map_len);
 void defvert_normalize(struct MDeformVert *dvert);
diff --git a/source/blender/blenkernel/intern/deform.c b/source/blender/blenkernel/intern/deform.c
index 021433dee9e..1f09d98d697 100644
--- a/source/blender/blenkernel/intern/deform.c
+++ b/source/blender/blenkernel/intern/deform.c
@@ -45,7 +45,7 @@
 #include "BLI_utildefines.h"
 
 
-void defgroup_copy_list (ListBase *outbase, ListBase *inbase)
+void defgroup_copy_list(ListBase *outbase, ListBase *inbase)
 {
 	bDeformGroup *defgroup, *defgroupn;
 
@@ -57,7 +57,7 @@ void defgroup_copy_list (ListBase *outbase, ListBase *inbase)
 	}
 }
 
-bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
+bDeformGroup *defgroup_duplicate(bDeformGroup *ingroup)
 {
 	bDeformGroup *outgroup;
 
@@ -65,7 +65,7 @@ bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
 		return NULL;
 
 	outgroup=MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
-	
+
 	/* For now, just copy everything over. */
 	memcpy (outgroup, ingroup, sizeof(bDeformGroup));
 
@@ -75,22 +75,22 @@ bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
 }
 
 /* copy & overwrite weights */
-void defvert_copy (MDeformVert *dvert_r, const MDeformVert *dvert)
+void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
 {
-	if(dvert_r->totweight == dvert->totweight) {
-		if(dvert->totweight)
-			memcpy(dvert_r->dw, dvert->dw, dvert->totweight * sizeof(MDeformWeight));
+	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_r->dw)
-			MEM_freeN(dvert_r->dw);
+		if (dvert_dst->dw)
+			MEM_freeN(dvert_dst->dw);
 
-		if(dvert->totweight)
-			dvert_r->dw= MEM_dupallocN(dvert->dw);
+		if (dvert_src->totweight)
+			dvert_dst->dw= MEM_dupallocN(dvert_src->dw);
 		else
-			dvert_r->dw= NULL;
+			dvert_dst->dw= NULL;
 
-		dvert_r->totweight = dvert->totweight;
+		dvert_dst->totweight = dvert_src->totweight;
 	}
 }
 
@@ -98,20 +98,20 @@ void defvert_copy (MDeformVert *dvert_r, const MDeformVert *dvert)
  * - do nothing if neither are set.
  * - add destination weight if needed.
  */
-void defvert_copy_index (MDeformVert *dv_dst, const MDeformVert *dv_src, const int defgroup)
+void defvert_copy_index(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const int defgroup)
 {
 	MDeformWeight *dw_src, *dw_dst;
 
-	dw_src= defvert_find_index(dv_src, defgroup);
+	dw_src= defvert_find_index(dvert_src, defgroup);
 
 	if (dw_src) {
 		/* source is valid, verify destination */
-		dw_dst= defvert_verify_index(dv_dst, defgroup);
+		dw_dst= defvert_verify_index(dvert_dst, defgroup);
 		dw_dst->weight= dw_src->weight;
 	}
 	else {
 		/* source was NULL, assign zero, could also remove */
-		dw_dst= defvert_find_index(dv_dst, defgroup);
+		dw_dst= defvert_find_index(dvert_dst, defgroup);
 
 		if (dw_dst) {
 			dw_dst->weight= 0.0f;
@@ -122,37 +122,38 @@ void defvert_copy_index (MDeformVert *dv_dst, const MDeformVert *dv_src, const i
 /* only sync over matching weights, don't add or remove groups
  * warning, loop within loop.
  */
-void defvert_sync (MDeformVert *dvert_r, const MDeformVert *dvert, int use_verify)
+void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, int use_verify)
 {
-	if(dvert->totweight && dvert_r->totweight) {
+	if (dvert_src->totweight && dvert_dst->totweight) {
 		int i;
-		MDeformWeight *dw;
-		for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++) {
-			MDeformWeight *dw_r;
-			if(use_verify)	dw_r= defvert_verify_index(dvert_r, dw->def_nr);
-			else			dw_r= defvert_find_index(dvert_r, dw->def_nr);
-
-			if(dw_r) {
-				dw_r->weight= dw->weight;
+		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_r, const MDeformVert *dvert, const int *flip_map, const int flip_map_len, const int use_verify)
+void defvert_sync_mapped(MDeformVert *dvert_dst, const MDeformVert *dvert_src,
+                         const int *flip_map, const int flip_map_len, const int use_verify)
 {
-	if (dvert->totweight && dvert_r->totweight) {
+	if (dvert_src->totweight && dvert_dst->totweight) {
 		int i;
-		MDeformWeight *dw;
-		for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++) {
-			if (dw->def_nr < flip_map_len) {
-				MDeformWeight *dw_r;
-				if(use_verify)	dw_r= defvert_verify_index(dvert_r, flip_map[dw->def_nr]);
-				else			dw_r= defvert_find_index(dvert_r, flip_map[dw->def_nr]);
-
-				if(dw_r) {
-					dw_r->weight= dw->weight;
+		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;
 				}
 			}
 		}
@@ -160,18 +161,18 @@ void defvert_sync_mapped (MDeformVert *dvert_r, const MDeformVert *dvert, const
 }
 
 /* be sure all flip_map values are valid */
-void defvert_remap (MDeformVert *dvert, int *map)
+void defvert_remap(MDeformVert *dvert, int *map)
 {
 	MDeformWeight *dw;
 	int i;
-	for(i=0, dw=dvert->dw; i<dvert->totweight; i++, dw++) {
+	for (i=0, dw=dvert->dw; i<dvert->totweight; i++, dw++) {
 		dw->def_nr= map[dw->def_nr];
 	}
 }
 
-void defvert_normalize (MDeformVert *dvert)
+void defvert_normalize(MDeformVert *dvert)
 {
-	if(dvert->totweight<=0) {
+	if (dvert->totweight<=0) {
 		/* nothing */
 	}
 	else if (dvert->totweight==1) {
@@ -181,30 +182,30 @@ void defvert_normalize (MDeformVert *dvert)
 		int i;
 		float tot= 0.0f;
 		MDeformWeight *dw;
-		for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
+		for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
 			tot += dw->weight;
 
-		if(tot > 0.0f) {
-			for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
+		if (tot > 0.0f) {
+			for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
 				dw->weight /= tot;
 		}
 	}
 }
 
-void defvert_flip (MDeformVert *dvert, const int *flip_map, const int flip_map_len)
+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) && (flip_map[dw->def_nr] >= 0)) {
+	for (dw= dvert->dw, i=0; i<dvert->totweight; dw++, i++) {
+		if ((dw->def_nr < flip_map_len) && (flip_map[dw->def_nr] >= 0)) {
 			dw->def_nr= flip_map[dw->def_nr];
 		}
 	}
 }
 
 
-bDeformGroup *defgroup_find_name (Object *ob, const char *name)
+bDeformGroup *defgroup_find_name(Object *ob, const char *name)
 {
 	/* return a pointer to the deform group with this name
 	 * or return NULL otherwise.
@@ -219,7 +220,7 @@ bDeformGroup *defgroup_find_name (Object *ob, const char *name)
 	return NULL;
 }
 
-int defgroup_name_index (Object *ob, const char *name)
+int defgroup_name_index(Object *ob, const char *name)
 {
 	/* Return the location of the named deform group within the list of
 	 * deform groups. This function is a combination of defgroup_find_index and
@@ -228,8 +229,8 @@ int defgroup_name_index (Object *ob, const char *name)
 	 */
 	bDeformGroup *curdef;
 	int def_nr;
-	
-	if(name && name[0] != '\0') {
+
+	if (name && name[0] != '\0') {
 		for (curdef=ob->defbase.first, def_nr=0; curdef; curdef=curdef->next, def_nr++) {
 			if (!strcmp(curdef->name, name))
 				return def_nr;
@@ -239,7 +240,7 @@ int defgroup_name_index (Object *ob, const char *name)
 	return -1;
 }
 
-int defgroup_find_index (Object *ob, bDeformGroup *dg)
+int defgroup_find_index(Object *ob, bDeformGroup *dg)
 {
 	/* Fetch the location of this deform group
 	 * within the linked list of deform groups.
@@ -275,7 +276,7 @@ int defgroup_find_index (Object *ob, bDeformGroup *dg)
 	 * constant for this)
 	 */
 	if (eg == NULL) return -1;
-	
+
 	return def_nr;
 }
 
@@ -284,7 +285,7 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, int use_default)
 {
 	int totdg= *flip_map_len= BLI_countlist(&ob->defbase);
 
-	if(totdg==0) {
+	if (totdg==0) {
 		return NULL;
 	}
 	else {
@@ -297,16 +298,16 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, int use_default)
 		}
 
 		for (dg=ob->defbase.first, i=0; dg; dg=dg->next, i++) {
-			if(map[i] == -1) { /* may be calculated previously */
+			if (map[i] == -1) { /* may be calculated previously */
 
 				/* incase no valid value is found, use this */
-				if(use_default)
+				if (use_default)
 					map[i]= i;
 
 				flip_side_name(name, dg->name, FALSE);
-				if(strcmp(name, dg->name)) {
+				if (strcmp(name, dg->name)) {
 					flip_num= defgroup_name_index(ob, name);
-					if(flip_num >= 0) {
+					if (flip_num >= 0) {
 						map[i]= flip_num;
 						map[flip_num]= i; /* save an extra lookup */
 					}
@@ -322,7 +323,7 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, int use_default, in
 {
 	int totdg= *flip_map_len= BLI_countlist(&ob->defbase);
 
-	if(totdg==0) {
+	if (totdg==0) {
 		return NULL;
 	}
 	else {
@@ -338,10 +339,10 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, int use_default, in
 		dg= BLI_findlink(&ob->defbase, defgroup);
 
 		flip_side_name(name, dg->name, FALSE);
-		if(strcmp(name, dg->name)) {
+		if (strcmp(name, dg->name)) {
 			flip_num= defgroup_name_index(ob, name);
 
-			if(flip_num >= 0) {
+			if (flip_num >= 0) {
 				map[defgroup]= flip_num;
 				map[flip_num]= defgroup;
 			}
@@ -356,11 +357,11 @@ int defgroup_flip_index(Object *ob, int index, int use_default)
 	bDeformGroup *dg= BLI_findlink(&ob->defbase, index);
 	int flip_index = -1;
 
-	if(dg) {
+	if (dg) {
 		char name[sizeof(dg->name)];
 		flip_side_name(name, dg->name, 0);
 
-		if(strcmp(name, dg->name))
+		if (strcmp(name, dg->name))
 			flip_index= defgroup_name_index(ob, name);
 	}
 
@@ -370,7 +371,7 @@ int defgroup_flip_index(Object *ob, int index, int use_default)
 static int defgroup_find_name_dupe(const char *name, bDeformGroup *dg, Object *ob)
 {
 	bDeformGroup *curdef;
-	
+
 	for (curdef = ob->defbase.first; curdef; curdef=curdef->next) {
 		if (dg!=curdef) {
 			if (!strcmp(curdef->name, name)) {
@@ -388,7 +389,7 @@ static int defgroup_unique_check(void *arg, const char *name)
 	return defgroup_find_name_dupe(name, data->dg, data->ob);
 }
 
-void defgroup_unique_name (bDeformGroup *dg, Object *ob)
+void defgroup_unique_name(bDeformGroup *dg, Object *ob)
 {
 	struct {Object *ob; void *dg;} data;
 	data.ob= ob;
@@ -400,7 +401,7 @@ void defgroup_unique_name (bDeformGroup *dg, Object *ob)
 /* finds the best possible flipped name. For renaming; check for unique names afterwards */
 /* if strip_number: removes number extensions
  * note: dont use sizeof() for 'name' or 'from_name' */
-void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP_NAME], int strip_number)
+void flip_side_name(char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP_NAME], int strip_number)
 {
 	int     len;
 	char    prefix[MAX_VGROUP_NAME]=  "";   /* The part before the facing */
@@ -410,15 +411,15 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 	char    *index=NULL;
 
 	len= BLI_strnlen(from_name, MAX_VGROUP_NAME);
-	if(len<3) return; // we don't do names like .R or .L
+	if (len < 3) return; // we don't do names like .R or .L
 
 	BLI_strncpy(name, from_name, MAX_VGROUP_NAME);
 
 	/* We first check the case with a .### extension, let's find the last period */
-	if(isdigit(name[len-1])) {
+	if (isdigit(name[len-1])) {
 		index= strrchr(name, '.'); // last occurrence
 		if (index && isdigit(index[1]) ) { // doesnt handle case bone.1abc2 correct..., whatever!
-			if(strip_number==0)
+			if (strip_number==0)
 				BLI_strncpy(number, index, sizeof(number));
 			*index= 0;
 			len= BLI_strnlen(name, MAX_VGROUP_NAME);
@@ -430,7 +431,7 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 #define IS_SEPARATOR(a) ((a)=='.' || (a)==' ' || (a)=='-' || (a)=='_')
 
 	/* first case; separator . - _ with extensions r R l L  */
-	if( IS_SEPARATOR(name[len-2]) ) {
+	if (IS_SEPARATOR(name[len-2]) ) {
 		switch(name[len-1]) {
 			case 'l':
 				prefix[len-1]= 0;
@@ -451,7 +452,7 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 		}
 	}
 	/* case; beginning with r R l L , with separator after it */
-	else if( IS_SEPARATOR(name[1]) ) {
+	else if (IS_SEPARATOR(name[1]) ) {
 		switch(name[0]) {
 			case 'l':
 				strcpy(replace, "r");
@@ -475,14 +476,14 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 				break;
 		}
 	}
-	else if(len > 5) {
+	else if (len > 5) {
 		/* hrms, why test for a separator? lets do the rule 'ultimate left or right' */
 		index = BLI_strcasestr(prefix, "right");
 		if (index==prefix || index==prefix+len-5) {
-			if(index[0]=='r')
+			if (index[0]=='r')
 				strcpy (replace, "left");
 			else {
-				if(index[1]=='I')
+				if (index[1]=='I')
 					strcpy (replace, "LEFT");
 				else
 					strcpy (replace, "Left");
@@ -493,10 +494,10 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 		else {
 			index = BLI_strcasestr(prefix, "left");
 			if (index==prefix || index==prefix+len-4) {
-				if(index[0]=='l')
+				if (index[0]=='l')
 					strcpy (replace, "right");
 				else {
-					if(index[1]=='E')
+					if (index[1]=='E')
 						strcpy (replace, "RIGHT");
 					else
 						strcpy (replace, "Right");
@@ -512,30 +513,32 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
 	BLI_snprintf (name, MAX_VGROUP_NAME, "%s%s%s%s", prefix, replace, suffix, number);
 }
 
-float defvert_find_weight(const struct MDeformVert *dvert, const int group_num)
+float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
 {
-	MDeformWeight *dw= defvert_find_index(dvert, group_num);
+	MDeformWeight *dw= defvert_find_index(dvert, defgroup);
 	return dw ? dw->weight : 0.0f;
 }
 
-float defvert_array_find_weight_safe(const struct MDeformVert *dvert, int index, int group_num)
+float defvert_array_find_weight_safe(const struct MDeformVert *dvert, const int index, const int defgroup)
 {
-	if(group_num == -1 || dvert == NULL)
+	if (defgroup == -1 || dvert == NULL)
 		return 1.0f;
 
-	return defvert_find_weight(dvert+index, group_num);
+	return defvert_find_weight(dvert+index, defgroup);
 }
 
 
 MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
 {
-	if(dvert && defgroup >= 0) {
+	if (dvert && defgroup >= 0) {
 		MDeformWeight *dw = dvert->dw;
 		int i;
 
-		for(i=dvert->totweight; i>0; i--, dw++)
-			if(dw->def_nr == defgroup)
+		for (i=dvert->totweight; i>0; i--, dw++) {
+			if (dw->def_nr == defgroup) {
 				return dw;
+			}
+		}
 	}
 
 	return NULL;
@@ -543,30 +546,74 @@ MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
 
 /* Ensures that mv has a deform weight entry for the specified defweight group */
 /* Note this function is mirrored in editmesh_tools.c, for use for editvertices */
-MDeformWeight *defvert_verify_index(MDeformVert *dv, const int defgroup)
+MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
 {
-	MDeformWeight *newdw;
+	MDeformWeight *dw_new;
 
 	/* do this check always, this function is used to check for it */
-	if(!dv || defgroup < 0)
+	if (!dvert || defgroup < 0)
 		return NULL;
 
-	newdw= defvert_find_index(dv, defgroup);
-	if(newdw)
-		return newdw;
+	dw_new= defvert_find_index(dvert, defgroup);
+	if (dw_new)
+		return dw_new;
 
-	newdw= MEM_callocN(sizeof(MDeformWeight)*(dv->totweight+1), "deformWeight");
-	if (dv->dw) {
-		memcpy(newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
-		MEM_freeN(dv->dw);
+	dw_new= MEM_callocN(sizeof(MDeformWeight)*(dvert->totweight+1), "deformWeight");
+	if (dvert->dw) {
+		memcpy(dw_new, dvert->dw, sizeof(MDeformWeight)*dvert->totweight);
+		MEM_freeN(dvert->dw);
 	}
-	dv->dw= newdw;
-	newdw += dv->totweight;
-	newdw->weight= 0.0f;
-	newdw->def_nr= defgroup;
+	dvert->dw= dw_new;
+	dw_new += dvert->totweight;
+	dw_new->weight= 0.0f;
+	dw_new->def_nr= defgroup;
 	/* Group index */
 
-	dv->totweight++;
+	dvert->totweight++;
+
+	return dw_new;
+}
 
-	return newdw;
+/* Removes the given vertex from the vertex group, specified either by its defgrp_idx,
+ * or directly by its MDeformWeight pointer, if dw is not NULL.
+ * WARNING: This function frees the given MDeformWeight, do not use it afterward! */
+void defvert_remove_index(MDeformVert *dvert, int defgroup, MDeformWeight *dw)
+{
+	MDeformWeight *dw_new;
+	int i;
+
+	/* Get index of removed MDeformWeight. */
+	if (dw == NULL) {
+		dw = dvert->dw;
+		for (i = dvert->totweight; i > 0; i--, dw++) {
+			if (dw->def_nr == defgroup)
+				break;
+		}
+		i--;
+	}
+	else {
+		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) {
+		dw_new = MEM_mallocN(sizeof(MDeformWeight)*(dvert->totweight), __func__);
+		if (dvert->dw){
+			memcpy(dw_new, dvert->dw, sizeof(MDeformWeight)*i);
+			memcpy(dw_new+i, dvert->dw+i+1, sizeof(MDeformWeight)*(dvert->totweight-i));
+			MEM_freeN(dvert->dw);
+		}
+		dvert->dw = dw_new;
+	}
+	else {
+		/* If there are no other deform weights left then just remove this one. */
+		MEM_freeN(dvert->dw);
+		dvert->dw = NULL;
+	}
 }
diff --git a/source/blender/modifiers/intern/MOD_weightvg_util.c b/source/blender/modifiers/intern/MOD_weightvg_util.c
index c2a9ae7555d..e206000f41d 100644
--- a/source/blender/modifiers/intern/MOD_weightvg_util.c
+++ b/source/blender/modifiers/intern/MOD_weightvg_util.c
@@ -240,51 +240,6 @@ static void defvert_add_to_group(MDeformVert *dv, int defgrp_idx, const float we
 	dv->totweight++;
 }
 
-/* Removes the given vertex from the vertex group, specified either by its defgrp_idx,
- * or directly by its MDeformWeight pointer, if dw is not NULL.
- * WARNING: This function frees the given MDeformWeight, do not use it afterward! */
-static void defvert_remove_from_group(MDeformVert *dv, int defgrp_idx, MDeformWeight *dw)
-{
-	/* TODO, move this into deform.c as a generic function. */
-	MDeformWeight *newdw;
-	int i;
-
-	/* Get index of removed MDeformWeight. */
-	if(dw == NULL) {
-		dw = dv->dw;
-		for (i = dv->totweight; i > 0; i--, dw++) {
-			if (dw->def_nr == defgrp_idx)
-				break;
-		}
-		i--;
-	}
-	else {
-		i = dw - dv->dw;
-		/* Security check! */
-		if(i < 0 || i >= dv->totweight)
-			return;
-	}
-
-	dv->totweight--;
-	/* If there are still other deform weights attached to this vert then remove
-	 * this deform weight, and reshuffle the others.
-	 */
-	if(dv->totweight) {
-		newdw = MEM_mallocN(sizeof(MDeformWeight)*(dv->totweight), "defvert_remove_from_group, new deformWeight");
-		if(dv->dw){
-			memcpy(newdw, dv->dw, sizeof(MDeformWeight)*i);
-			memcpy(newdw+i, dv->dw+i+1, sizeof(MDeformWeight)*(dv->totweight-i));
-			MEM_freeN(dv->dw);
-		}
-		dv->dw = newdw;
-	}
-	/* If there are no other deform weights left then just remove this one. */
-	else {
-		MEM_freeN(dv->dw);
-		dv->dw = NULL;
-	}
-}
-
 
 /* Applies weights to given vgroup (defgroup), and optionnaly add/remove vertices from the group.
  * If dws is not NULL, it must be an array of MDeformWeight pointers of same length as weights (and
@@ -309,7 +264,7 @@ void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, MDeformWeight **dws,
 		/* If the vertex is in this vgroup, remove it if needed, or just update it. */
 		if(dw != NULL) {
 			if(do_rem && w < rem_thresh) {
-				defvert_remove_from_group(dv, defgrp_idx, dw);
+				defvert_remove_index(dv, defgrp_idx, dw);
 			}
 			else {
 				dw->weight = w;