svn merge -r40166:40279 ^/trunk/blender

6 files changed, 182 insertions, 144 deletions

diff --git a/source/blender/modifiers/intern/MOD_warp.c b/source/blender/modifiers/intern/MOD_warp.c
index e6e9c347e6d..8eb1bace229 100644
--- a/source/blender/modifiers/intern/MOD_warp.c
+++ b/source/blender/modifiers/intern/MOD_warp.c
@@ -232,8 +232,8 @@ static void warpModifier_do(WarpModifierData *wmd, Object *ob,
 				dv = &dvert[i];
 
 				if(dv) {
-					weight = defvert_find_weight(dv, defgrp_index) * wmd->strength;
-					if(weight <= 0.0f)
+					weight = defvert_find_weight(dv, defgrp_index) * strength;
+					if(weight <= 0.0f) /* Should never occure... */
 						continue;
 				}
 			}
diff --git a/source/blender/modifiers/intern/MOD_weightvg_util.c b/source/blender/modifiers/intern/MOD_weightvg_util.c
index 98615c70553..128e888ca90 100644
--- a/source/blender/modifiers/intern/MOD_weightvg_util.c
+++ b/source/blender/modifiers/intern/MOD_weightvg_util.c
@@ -212,7 +212,7 @@ void weightvg_do_mask(int num, const int *indices, float *org_w, const float *ne
 		/* For each weight (vertex), make the mix between org and new weights. */
 		for (i = 0; i < num; i++) {
 			int idx = indices ? indices[i] : i;
-			const float f= defvert_find_weight(&dvert[idx], ref_didx) * fact;
+			const float f = defvert_find_weight(&dvert[idx], ref_didx) * fact;
 			org_w[i] = (new_w[i] * f) + (org_w[i] * (1.0f-f));
 			/* If that vertex is not in ref vgroup, assume null factor, and hence do nothing! */
 		}
@@ -220,87 +220,107 @@ void weightvg_do_mask(int num, const int *indices, float *org_w, const float *ne
 	else {
 		/* Default "influence" behavior. */
 		/* For each weight (vertex), make the mix between org and new weights. */
-		const float ifact= 1.0f - fact;
+		const float ifact = 1.0f - fact;
 		for (i = 0; i < num; i++) {
 			org_w[i] = (new_w[i] * fact) + (org_w[i] * ifact);
 		}
 	}
 }
 
+/* Adds the given vertex to the specified vertex group, with given weight. */
+static void defvert_add_to_group(MDeformVert *dv, int defgrp_idx, const float weight) {
+	/* TODO, move into deform.c as a generic function. This assumes the vertex
+	 * groups have already been checked, so this has to remain low level. */
+	MDeformWeight *newdw;
+
+	newdw = MEM_callocN(sizeof(MDeformWeight)*(dv->totweight+1), "defvert_add_to group, new deformWeight");
+	if(dv->dw) {
+		memcpy(newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
+		MEM_freeN(dv->dw);
+	}
+	dv->dw = newdw;
+	dv->dw[dv->totweight].weight = weight;
+	dv->dw[dv->totweight].def_nr = defgrp_idx;
+	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 indices is not NULL, it must be a table of same length as weights, mapping to the real
- * vertex index (in case the weight table does not cover the whole vertices...).
+ * If dws is not NULL, it must be an array of MDeformWeight pointers of same length as weights (and
+ * defgrp_idx can then have any value).
+ * If indices is not NULL, it must be an array of same length as weights, mapping to the real
+ * vertex index (in case the weight array does not cover the whole vertices...).
  */
-void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, int num,
+void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, MDeformWeight **dws, int num,
                         const int *indices, const float *weights, int do_add,
                         float add_thresh, int do_rem, float rem_thresh)
 {
 	int i;
 
-	for (i = 0; i < num; i++) {
-		int j;
-		int add2vg = do_add;
+	for(i = 0; i < num; i++) {
 		float w = weights[i];
 		MDeformVert *dv = &dvert[indices ? indices[i] : i];
-		MDeformWeight *newdw;
+		MDeformWeight *dw = dws ? dws[i] : defvert_find_index(dv, defgrp_idx);
 
 		/* Never allow weights out of [0.0, 1.0] range. */
 		CLAMP(w, 0.0f, 1.0f);
 
-		/* Let's first check to see if this vert is already in the weight group – if so
-		 * let's update it, or remove it if needed.
-		 */
-		for (j = 0; j < dv->totweight; j++) {
-			/* If this weight corresponds to the deform group, update the value or,
-			 * if lower than rem_threshold, remove the vertex from the vgroup.
-			 */
-			if (dv->dw[j].def_nr == defgrp_idx) {
-				/* Remove the vertex from this vgroup if needed. */
-				if (do_rem && w < rem_thresh) {
-					/* TODO, move this into deform.c to make into a generic function */
-
-					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), "deformWeight");
-						if(dv->dw){
-							memcpy(newdw, dv->dw, sizeof(MDeformWeight)*j);
-							memcpy(newdw+j, dv->dw+j+1, sizeof(MDeformWeight)*(dv->totweight-j));
-							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;
-					}
-				}
-				/* Else, just set the new computed weight. */
-				else {
-					dv->dw[j].weight = w;
-				}
-				add2vg = FALSE;
-				break;
+		/* 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);
 			}
-		}
-
-		/* If the vert wasn't in the deform group, add it if needed!
-		 */
-		if ((add2vg == TRUE) && w > add_thresh) {
-			/* TODO, mvoe into deform.c and make into a generic function, this assumes the vertex
-			 * groups have already been checked, so this has to remain low level */
-			newdw = MEM_callocN(sizeof(MDeformWeight)*(dv->totweight+1), "WeightVGEdit Modifier, deformWeight");
-			if(dv->dw) {
-				memcpy(newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
-				MEM_freeN(dv->dw);
+			else {
+				dw->weight = w;
 			}
-			dv->dw = newdw;
-			dv->dw[dv->totweight].weight = w;
-			dv->dw[dv->totweight].def_nr = defgrp_idx;
-			dv->totweight++;
+		}
+		/* Else, add it if needed! */
+		else if(do_add && w > add_thresh) {
+			defvert_add_to_group(dv, defgrp_idx, w);
 		}
 	}
 }
diff --git a/source/blender/modifiers/intern/MOD_weightvg_util.h b/source/blender/modifiers/intern/MOD_weightvg_util.h
index ce3520f1900..a327bdf969b 100644
--- a/source/blender/modifiers/intern/MOD_weightvg_util.h
+++ b/source/blender/modifiers/intern/MOD_weightvg_util.h
@@ -83,7 +83,7 @@ void weightvg_do_mask(int num, const int *indices, float *org_w, const float *ne
  * If indices is not NULL, it must be a table of same length as weights, mapping to the real
  * vertex index (in case the weight table does not cover the whole vertices...).
  */
-void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, int num,
+void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, MDeformWeight **dws, int num,
                         const int *indices, const float *weights, int do_add,
                         float add_thresh, int do_rem, float rem_thresh);
 
diff --git a/source/blender/modifiers/intern/MOD_weightvgedit.c b/source/blender/modifiers/intern/MOD_weightvgedit.c
index fffb3c6de2f..8e609ad5929 100644
--- a/source/blender/modifiers/intern/MOD_weightvgedit.c
+++ b/source/blender/modifiers/intern/MOD_weightvgedit.c
@@ -187,6 +187,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	Mesh *ob_m = NULL;
 #endif
 	MDeformVert *dvert = NULL;
+	MDeformWeight **dw = NULL;
 	float *org_w; /* Array original weights. */
 	float *new_w; /* Array new weights. */
 	int numVerts;
@@ -257,13 +258,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 
 	/* Get org weights, assuming 0.0 for vertices not in given vgroup. */
 	org_w = MEM_mallocN(sizeof(float) * numVerts, "WeightVGEdit Modifier, org_w");
-	new_w = MEM_mallocN(sizeof(float) * numVerts, "WeightVGEdit Modifier, org_w");
+	new_w = MEM_mallocN(sizeof(float) * numVerts, "WeightVGEdit Modifier, new_w");
+	dw = MEM_mallocN(sizeof(MDeformWeight*) * numVerts, "WeightVGEdit Modifier, dw");
 	for (i = 0; i < numVerts; i++) {
-		MDeformWeight *dw= defvert_find_index(&dvert[i], defgrp_idx);
-		org_w[i] = new_w[i] = wmd->default_weight;
-
-		if(dw) {
-			org_w[i] = new_w[i] = dw->weight;
+		dw[i] = defvert_find_index(&dvert[i], defgrp_idx);
+		if(dw[i]) {
+			org_w[i] = new_w[i] = dw[i]->weight;
+		}
+		else {
+			org_w[i] = new_w[i] = wmd->default_weight;
 		}
 	}
 
@@ -278,12 +281,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	                 wmd->mask_tex_mapping, wmd->mask_tex_map_obj, wmd->mask_tex_uvlayer_name);
 
 	/* Update/add/remove from vgroup. */
-	weightvg_update_vg(dvert, defgrp_idx, numVerts, NULL, org_w, do_add, wmd->add_threshold,
+	weightvg_update_vg(dvert, defgrp_idx, dw, numVerts, NULL, org_w, do_add, wmd->add_threshold,
 	                   do_rem, wmd->rem_threshold);
 
 	/* Freeing stuff. */
 	MEM_freeN(org_w);
 	MEM_freeN(new_w);
+	MEM_freeN(dw);
 
 	/* Return the vgroup-modified mesh. */
 	return ret;
diff --git a/source/blender/modifiers/intern/MOD_weightvgmix.c b/source/blender/modifiers/intern/MOD_weightvgmix.c
index 8093683a098..f30a2deb576 100644
--- a/source/blender/modifiers/intern/MOD_weightvgmix.c
+++ b/source/blender/modifiers/intern/MOD_weightvgmix.c
@@ -229,13 +229,14 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	Mesh *ob_m = NULL;
 #endif
 	MDeformVert *dvert = NULL;
+	MDeformWeight **dw1, **tdw1, **dw2, **tdw2;
 	int numVerts;
 	int defgrp_idx, defgrp_idx2 = -1;
 	float *org_w;
 	float *new_w;
 	int *tidx, *indices = NULL;
 	int numIdx = 0;
-	int i, j;
+	int i;
 	char rel_ret = 0; /* Boolean, whether we have to release ret dm or not, when not using it! */
 
 	/* Get number of verts. */
@@ -304,78 +305,91 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 
 	/* Find out which vertices to work on. */
 	tidx = MEM_mallocN(sizeof(int) * numVerts, "WeightVGMix Modifier, tidx");
+	tdw1 = MEM_mallocN(sizeof(MDeformWeight*) * numVerts, "WeightVGMix Modifier, tdw1");
+	tdw2 = MEM_mallocN(sizeof(MDeformWeight*) * numVerts, "WeightVGMix Modifier, tdw2");
 	switch (wmd->mix_set) {
 	case MOD_WVG_SET_A:
 		/* All vertices in first vgroup. */
 		for (i = 0; i < numVerts; i++) {
-			for (j = 0; j < dvert[i].totweight; j++) {
-				if(dvert[i].dw[j].def_nr == defgrp_idx) {
-					tidx[numIdx++] = i;
-					break;
-				}
+			MDeformWeight *dw = defvert_find_index(&dvert[i], defgrp_idx);
+			if(dw) {
+				tdw1[numIdx] = dw;
+				tdw2[numIdx] = defvert_find_index(&dvert[i], defgrp_idx2);
+				tidx[numIdx++] = i;
 			}
 		}
 		break;
 	case MOD_WVG_SET_B:
 		/* All vertices in second vgroup. */
 		for (i = 0; i < numVerts; i++) {
-			for (j = 0; j < dvert[i].totweight; j++) {
-				if(dvert[i].dw[j].def_nr == defgrp_idx2) {
-					tidx[numIdx++] = i;
-					break;
-				}
+			MDeformWeight *dw = defvert_find_index(&dvert[i], defgrp_idx2);
+			if(dw) {
+				tdw1[numIdx] = defvert_find_index(&dvert[i], defgrp_idx);
+				tdw2[numIdx] = dw;
+				tidx[numIdx++] = i;
 			}
 		}
 		break;
 	case MOD_WVG_SET_OR:
 		/* All vertices in one vgroup or the other. */
 		for (i = 0; i < numVerts; i++) {
-			for (j = 0; j < dvert[i].totweight; j++) {
-				if(dvert[i].dw[j].def_nr == defgrp_idx || dvert[i].dw[j].def_nr == defgrp_idx2) {
-					tidx[numIdx++] = i;
-					break;
-				}
+			MDeformWeight *adw = defvert_find_index(&dvert[i], defgrp_idx);
+			MDeformWeight *bdw = defvert_find_index(&dvert[i], defgrp_idx2);
+			if(adw || bdw) {
+				tdw1[numIdx] = adw;
+				tdw2[numIdx] = bdw;
+				tidx[numIdx++] = i;
 			}
 		}
 		break;
 	case MOD_WVG_SET_AND:
 		/* All vertices in both vgroups. */
 		for (i = 0; i < numVerts; i++) {
-			int idx1 = FALSE;
-			int idx2 = FALSE;
-			for (j = 0; j < dvert[i].totweight; j++) {
-				if(dvert[i].dw[j].def_nr == defgrp_idx) {
-					if (idx2 == TRUE) {
-						tidx[numIdx++] = i;
-						break;
-					}
-					else {
-						idx1 = TRUE;
-					}
-				}
-				else if(dvert[i].dw[j].def_nr == defgrp_idx2) {
-					if (idx1 == TRUE) {
-						tidx[numIdx++] = i;
-						break;
-					}
-					else {
-						idx2 = TRUE;
-					}
-				}
+			MDeformWeight *adw = defvert_find_index(&dvert[i], defgrp_idx);
+			MDeformWeight *bdw = defvert_find_index(&dvert[i], defgrp_idx2);
+			if(adw && bdw) {
+				tdw1[numIdx] = adw;
+				tdw2[numIdx] = bdw;
+				tidx[numIdx++] = i;
 			}
 		}
 		break;
 	case MOD_WVG_SET_ALL:
 	default:
-		/* Use all vertices, no need to do anything here. */
+		/* Use all vertices. */
+		for (i = 0; i < numVerts; i++) {
+			tdw1[i] = defvert_find_index(&dvert[i], defgrp_idx);
+			tdw2[i] = defvert_find_index(&dvert[i], defgrp_idx2);
+		}
+		numIdx = -1;
 		break;
 	}
-	if (numIdx) {
+	if(numIdx == 0) {
+		/* Use no vertices! Hence, return org data. */
+		MEM_freeN(tdw1);
+		MEM_freeN(tdw2);
+		MEM_freeN(tidx);
+		if (rel_ret)
+			ret->release(ret);
+		return dm;
+	}
+	if (numIdx != -1) {
 		indices = MEM_mallocN(sizeof(int) * numIdx, "WeightVGMix Modifier, indices");
 		memcpy(indices, tidx, sizeof(int) * numIdx);
+		dw1 = MEM_mallocN(sizeof(MDeformWeight*) * numIdx, "WeightVGMix Modifier, dw1");
+		memcpy(dw1, tdw1, sizeof(MDeformWeight*) * numIdx);
+		MEM_freeN(tdw1);
+		dw2 = MEM_mallocN(sizeof(MDeformWeight*) * numIdx, "WeightVGMix Modifier, dw2");
+		memcpy(dw2, tdw2, sizeof(MDeformWeight*) * numIdx);
+		MEM_freeN(tdw2);
 	}
-	else
+	else {
+		/* Use all vertices. */
 		numIdx = numVerts;
+		/* Just copy MDeformWeight pointers arrays, they will be freed at the end. */
+		dw1 = tdw1;
+		dw2 = tdw2;
+	}
 	MEM_freeN(tidx);
 
 	org_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGMix Modifier, org_w");
@@ -384,27 +398,9 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	/* Mix weights. */
 	for (i = 0; i < numIdx; i++) {
 		float weight2 = 0.0;
-		int w1 = FALSE;
-		int w2 = FALSE;
-		int idx = indices ? indices[i] : i;
-		for (j = 0; j < dvert[idx].totweight; j++) {
-			if(dvert[idx].dw[j].def_nr == defgrp_idx) {
-				org_w[i] = dvert[idx].dw[j].weight;
-				w1 = TRUE;
-				if (w2 == TRUE)
-					break;
-			}
-			else if(dvert[idx].dw[j].def_nr == defgrp_idx2) {
-				weight2 = dvert[idx].dw[j].weight;
-				w2 = TRUE;
-				if (w1 == TRUE)
-					break;
-			}
-		}
-		if (w1 == FALSE)
-			org_w[i] = wmd->default_weight_a;
-		if (w2 == FALSE)
-			weight2 = wmd->default_weight_b;
+		org_w[i] = dw1[i] ? dw1[i]->weight : wmd->default_weight_a;
+		weight2  = dw2[i] ? dw2[i]->weight : wmd->default_weight_b;
+
 		new_w[i] = mix_weight(org_w[i], weight2, wmd->mix_mode);
 	}
 
@@ -416,11 +412,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	/* Update (add to) vgroup.
 	 * XXX Depending on the MOD_WVG_SET_xxx option chosen, we might have to add vertices to vgroup.
 	 */
-	weightvg_update_vg(dvert, defgrp_idx, numIdx, indices, org_w, TRUE, -FLT_MAX, 0, 0.0f);
+	weightvg_update_vg(dvert, defgrp_idx, dw1, numIdx, indices, org_w, TRUE, -FLT_MAX, FALSE, 0.0f);
 
 	/* Freeing stuff. */
 	MEM_freeN(org_w);
 	MEM_freeN(new_w);
+	MEM_freeN(dw1);
+	MEM_freeN(dw2);
 
 	if (indices)
 		MEM_freeN(indices);
diff --git a/source/blender/modifiers/intern/MOD_weightvgproximity.c b/source/blender/modifiers/intern/MOD_weightvgproximity.c
index 896b0d86c85..6242c6d0f5e 100644
--- a/source/blender/modifiers/intern/MOD_weightvgproximity.c
+++ b/source/blender/modifiers/intern/MOD_weightvgproximity.c
@@ -344,6 +344,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	Mesh *ob_m = NULL;
 #endif
 	MDeformVert *dvert = NULL;
+	MDeformWeight **dw, **tdw;
 	int numVerts;
 	float (*v_cos)[3] = NULL; /* The vertices coordinates. */
 	Object *obr = NULL; /* Our target object. */
@@ -353,7 +354,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	float *new_w =NULL;
 	int *tidx, *indices = NULL;
 	int numIdx = 0;
-	int i, j;
+	int i;
 	char rel_ret = 0; /* Boolean, whether we have to release ret dm or not, when not using it! */
 
 	/* Get number of verts. */
@@ -423,22 +424,34 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	 */
 	tidx = MEM_mallocN(sizeof(int) * numVerts, "WeightVGProximity Modifier, tidx");
 	tw = MEM_mallocN(sizeof(float) * numVerts, "WeightVGProximity Modifier, tw");
+	tdw = MEM_mallocN(sizeof(MDeformWeight*) * numVerts, "WeightVGProximity Modifier, tdw");
 	for (i = 0; i < numVerts; i++) {
-		for (j = 0; j < dvert[i].totweight; j++) {
-			if(dvert[i].dw[j].def_nr == defgrp_idx) {
-				tidx[numIdx] = i;
-				tw[numIdx++] = dvert[i].dw[j].weight;
-				break;
-			}
+		MDeformWeight *_dw = defvert_find_index(&dvert[i], defgrp_idx);
+		if(_dw) {
+			tidx[numIdx] = i;
+			tw[numIdx] = _dw->weight;
+			tdw[numIdx++] = _dw;
 		}
 	}
+	/* If no vertices found, return org data! */
+	if(numIdx == 0) {
+		MEM_freeN(tidx);
+		MEM_freeN(tw);
+		MEM_freeN(tdw);
+		if (rel_ret)
+			ret->release(ret);
+		return dm;
+	}
 	indices = MEM_mallocN(sizeof(int) * numIdx, "WeightVGProximity Modifier, indices");
 	memcpy(indices, tidx, sizeof(int) * numIdx);
 	org_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, org_w");
 	new_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, new_w");
 	memcpy(org_w, tw, sizeof(float) * numIdx);
+	dw = MEM_mallocN(sizeof(MDeformWeight*) * numIdx, "WeightVGProximity Modifier, dw");
+	memcpy(dw, tdw, sizeof(MDeformWeight*) * numIdx);
 	MEM_freeN(tidx);
 	MEM_freeN(tw);
+	MEM_freeN(tdw);
 
 	/* Get our vertex coordinates. */
 	v_cos = MEM_mallocN(sizeof(float[3]) * numIdx, "WeightVGProximity Modifier, v_cos");
@@ -447,7 +460,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 
 	/* Compute wanted distances. */
 	if (wmd->proximity_mode == MOD_WVG_PROXIMITY_OBJECT) {
-		float dist = get_ob2ob_distance(ob, obr);
+		const float dist = get_ob2ob_distance(ob, obr);
 		for(i = 0; i < numIdx; i++)
 			new_w[i] = dist;
 	}
@@ -482,8 +495,10 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 				                       target_dm, &loc2trgt);
 				for(i = 0; i < numIdx; i++) {
 					new_w[i] = dists_v ? dists_v[i] : FLT_MAX;
-					new_w[i] = dists_e ? minf(dists_e[i], new_w[i]) : new_w[i];
-					new_w[i] = dists_f ? minf(dists_f[i], new_w[i]) : new_w[i];
+					if(dists_e)
+						new_w[i] = minf(dists_e[i], new_w[i]);
+					if(dists_f)
+						new_w[i] = minf(dists_f[i], new_w[i]);
 				}
 				if(dists_v) MEM_freeN(dists_v);
 				if(dists_e) MEM_freeN(dists_e);
@@ -508,11 +523,12 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
 	                 wmd->mask_tex_mapping, wmd->mask_tex_map_obj, wmd->mask_tex_uvlayer_name);
 
 	/* Update vgroup. Note we never add nor remove vertices from vgroup here. */
-	weightvg_update_vg(dvert, defgrp_idx, numIdx, indices, org_w, 0, 0.0f, 0, 0.0f);
+	weightvg_update_vg(dvert, defgrp_idx, dw, numIdx, indices, org_w, FALSE, 0.0f, FALSE, 0.0f);
 
 	/* Freeing stuff. */
 	MEM_freeN(org_w);
 	MEM_freeN(new_w);
+	MEM_freeN(dw);
 	MEM_freeN(indices);
 	MEM_freeN(v_cos);