style cleanup: operator/whitespace

1 files changed, 454 insertions, 452 deletions

diff --git a/source/blender/editors/sculpt_paint/paint_vertex.c b/source/blender/editors/sculpt_paint/paint_vertex.c
index 59c034f1cd1..54f4d0c1a26 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.c
+++ b/source/blender/editors/sculpt_paint/paint_vertex.c
@@ -131,10 +131,10 @@ int vertex_paint_poll(bContext *C)
 {
 	if (vertex_paint_mode_poll(C) && 
 	   paint_brush(&CTX_data_tool_settings(C)->vpaint->paint)) {
-		ScrArea *sa= CTX_wm_area(C);
-		if (sa->spacetype==SPACE_VIEW3D) {
-			ARegion *ar= CTX_wm_region(C);
-			if (ar->regiontype==RGN_TYPE_WINDOW)
+		ScrArea *sa = CTX_wm_area(C);
+		if (sa->spacetype == SPACE_VIEW3D) {
+			ARegion *ar = CTX_wm_region(C);
+			if (ar->regiontype == RGN_TYPE_WINDOW)
 				return 1;
 			}
 		}
@@ -150,17 +150,17 @@ int weight_paint_mode_poll(bContext *C)
 
 int weight_paint_poll(bContext *C)
 {
-	Object *ob= CTX_data_active_object(C);
+	Object *ob = CTX_data_active_object(C);
 	ScrArea *sa;
 
-	if (	(ob != NULL) &&
-		(ob->mode & OB_MODE_WEIGHT_PAINT) &&
-		(paint_brush(&CTX_data_tool_settings(C)->wpaint->paint) != NULL) &&
-		(sa= CTX_wm_area(C)) &&
-		(sa->spacetype == SPACE_VIEW3D)
-	) {
-		ARegion *ar= CTX_wm_region(C);
-		if (ar->regiontype==RGN_TYPE_WINDOW) {
+	if ((ob != NULL) &&
+	    (ob->mode & OB_MODE_WEIGHT_PAINT) &&
+	    (paint_brush(&CTX_data_tool_settings(C)->wpaint->paint) != NULL) &&
+	    (sa = CTX_wm_area(C)) &&
+	    (sa->spacetype == SPACE_VIEW3D))
+	{
+		ARegion *ar = CTX_wm_region(C);
+		if (ar->regiontype == RGN_TYPE_WINDOW) {
 			return 1;
 		}
 	}
@@ -169,19 +169,19 @@ int weight_paint_poll(bContext *C)
 
 static VPaint *new_vpaint(int wpaint)
 {
-	VPaint *vp= MEM_callocN(sizeof(VPaint), "VPaint");
+	VPaint *vp = MEM_callocN(sizeof(VPaint), "VPaint");
 	
-	vp->flag= VP_AREA+VP_SPRAY;
+	vp->flag = VP_AREA + VP_SPRAY;
 	
 	if (wpaint)
-		vp->flag= VP_AREA;
+		vp->flag = VP_AREA;
 
 	return vp;
 }
 
 static int *get_indexarray(Mesh *me)
 {
-	return MEM_mallocN(sizeof(int)*(me->totpoly+1), "vertexpaint");
+	return MEM_mallocN(sizeof(int) * (me->totpoly + 1), "vertexpaint");
 }
 
 unsigned int vpaint_get_current_col(VPaint *vp)
@@ -203,54 +203,54 @@ static void do_shared_vertex_tesscol(Mesh *me)
 	short *scolmain, *scol;
 	char *mcol;
 	
-	if (me->mcol==NULL || me->totvert==0 || me->totface==0) return;
-	
-	scolmain= MEM_callocN(4*sizeof(short)*me->totvert, "colmain");
-	
-	tface= me->mtface;
-	mface= me->mface;
-	mcol= (char *)me->mcol;
-	for (a=me->totface; a>0; a--, mface++, mcol+=16) {
-		if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK)==0) {
-			scol= scolmain+4*mface->v1;
-			scol[0]++; scol[1]+= mcol[1]; scol[2]+= mcol[2]; scol[3]+= mcol[3];
-			scol= scolmain+4*mface->v2;
-			scol[0]++; scol[1]+= mcol[5]; scol[2]+= mcol[6]; scol[3]+= mcol[7];
-			scol= scolmain+4*mface->v3;
-			scol[0]++; scol[1]+= mcol[9]; scol[2]+= mcol[10]; scol[3]+= mcol[11];
+	if (me->mcol == NULL || me->totvert == 0 || me->totface == 0) return;
+	
+	scolmain = MEM_callocN(4 * sizeof(short) * me->totvert, "colmain");
+	
+	tface = me->mtface;
+	mface = me->mface;
+	mcol = (char *)me->mcol;
+	for (a = me->totface; a > 0; a--, mface++, mcol += 16) {
+		if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK) == 0) {
+			scol = scolmain + 4 * mface->v1;
+			scol[0]++; scol[1] += mcol[1]; scol[2] += mcol[2]; scol[3] += mcol[3];
+			scol = scolmain + 4 * mface->v2;
+			scol[0]++; scol[1] += mcol[5]; scol[2] += mcol[6]; scol[3] += mcol[7];
+			scol = scolmain + 4 * mface->v3;
+			scol[0]++; scol[1] += mcol[9]; scol[2] += mcol[10]; scol[3] += mcol[11];
 			if (mface->v4) {
-				scol= scolmain+4*mface->v4;
-				scol[0]++; scol[1]+= mcol[13]; scol[2]+= mcol[14]; scol[3]+= mcol[15];
+				scol = scolmain + 4 * mface->v4;
+				scol[0]++; scol[1] += mcol[13]; scol[2] += mcol[14]; scol[3] += mcol[15];
 			}
 		}
 		if (tface) tface++;
 	}
 	
-	a= me->totvert;
-	scol= scolmain;
+	a = me->totvert;
+	scol = scolmain;
 	while (a--) {
-		if (scol[0]>1) {
-			scol[1]/= scol[0];
-			scol[2]/= scol[0];
-			scol[3]/= scol[0];
-		}
-		scol+= 4;
-	}
-	
-	tface= me->mtface;
-	mface= me->mface;
-	mcol= (char *)me->mcol;
-	for (a=me->totface; a>0; a--, mface++, mcol+=16) {
-		if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK)==0) {
-			scol= scolmain+4*mface->v1;
-			mcol[1]= scol[1]; mcol[2]= scol[2]; mcol[3]= scol[3];
-			scol= scolmain+4*mface->v2;
-			mcol[5]= scol[1]; mcol[6]= scol[2]; mcol[7]= scol[3];
-			scol= scolmain+4*mface->v3;
-			mcol[9]= scol[1]; mcol[10]= scol[2]; mcol[11]= scol[3];
+		if (scol[0] > 1) {
+			scol[1] /= scol[0];
+			scol[2] /= scol[0];
+			scol[3] /= scol[0];
+		}
+		scol += 4;
+	}
+	
+	tface = me->mtface;
+	mface = me->mface;
+	mcol = (char *)me->mcol;
+	for (a = me->totface; a > 0; a--, mface++, mcol += 16) {
+		if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK) == 0) {
+			scol = scolmain + 4 * mface->v1;
+			mcol[1] = scol[1]; mcol[2] = scol[2]; mcol[3] = scol[3];
+			scol = scolmain + 4 * mface->v2;
+			mcol[5] = scol[1]; mcol[6] = scol[2]; mcol[7] = scol[3];
+			scol = scolmain + 4 * mface->v3;
+			mcol[9] = scol[1]; mcol[10] = scol[2]; mcol[11] = scol[3];
 			if (mface->v4) {
-				scol= scolmain+4*mface->v4;
-				mcol[13]= scol[1]; mcol[14]= scol[2]; mcol[15]= scol[3];
+				scol = scolmain + 4 * mface->v4;
+				mcol[13] = scol[1]; mcol[14] = scol[2]; mcol[15] = scol[3];
 			}
 		}
 		if (tface) tface++;
@@ -271,17 +271,17 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
 	/* if no mloopcol: do not do */
 	/* if mtexpoly: only the involved faces, otherwise all */
 
-	if (me->mloopcol==0 || me->totvert==0 || me->totpoly==0) return;
+	if (me->mloopcol == 0 || me->totvert == 0 || me->totpoly == 0) return;
 
-	scol = MEM_callocN(sizeof(float)*me->totvert*5, "scol");
+	scol = MEM_callocN(sizeof(float) * me->totvert * 5, "scol");
 
-	for (i=0; i<me->totloop; i++, ml++, lcol++) {
+	for (i = 0; i < me->totloop; i++, ml++, lcol++) {
 		if (i >= mp->loopstart + mp->totloop) {
 			mp++;
 			if (mtp) mtp++;
 		}
 
-		if (!(mtp && (mtp->mode & TF_SHAREDCOL)) && (me->editflag & ME_EDIT_PAINT_MASK)!=0)
+		if (!(mtp && (mtp->mode & TF_SHAREDCOL)) && (me->editflag & ME_EDIT_PAINT_MASK) != 0)
 			continue;
 
 		scol[ml->v][0] += lcol->r;
@@ -293,7 +293,7 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
 	}
 	
 	if (has_shared) {
-		for (i=0; i<me->totvert; i++) {
+		for (i = 0; i < me->totvert; i++) {
 			if (!scol[i][4]) continue;
 
 			scol[i][0] /= scol[i][4];
@@ -304,7 +304,7 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
 	
 		ml = me->mloop;
 		lcol = me->mloopcol;
-		for (i=0; i<me->totloop; i++, ml++, lcol++) {
+		for (i = 0; i < me->totloop; i++, ml++, lcol++) {
 			if (!scol[ml->v][4]) continue;
 
 			lcol->r = scol[ml->v][0];
@@ -325,8 +325,8 @@ static void make_vertexcol(Object *ob)	/* single ob */
 {
 	Mesh *me;
 	if (!ob || ob->id.lib) return;
-	me= get_mesh(ob);
-	if (me==NULL) return;
+	me = get_mesh(ob);
+	if (me == NULL) return;
 	if (me->edit_btmesh) return;
 
 	/* copies from shadedisplist to mcol */
@@ -345,10 +345,10 @@ static void make_vertexcol(Object *ob)	/* single ob */
 		if (!me->mcol || !me->mface) {
 			/* should always be true */
 			if (me->mcol) {
-				memset(me->mcol, 255, 4*sizeof(MCol)*me->totface);
+				memset(me->mcol, 255, 4 * sizeof(MCol) * me->totface);
 			}
 
-			/* create tessfaces because they will be used for drawing & fast updates*/
+			/* create tessfaces because they will be used for drawing & fast updates */
 			BKE_mesh_tessface_calc(me); /* does own call to update pointers */
 		}
 	}
@@ -370,7 +370,7 @@ static void make_vertexcol(Object *ob)	/* single ob */
 /* mirror_vgroup is set to -1 when invalid */
 static int wpaint_mirror_vgroup_ensure(Object *ob, const int vgroup_active)
 {
-	bDeformGroup *defgroup= BLI_findlink(&ob->defbase, vgroup_active);
+	bDeformGroup *defgroup = BLI_findlink(&ob->defbase, vgroup_active);
 
 	if (defgroup) {
 		bDeformGroup *curdef;
@@ -380,16 +380,16 @@ static int wpaint_mirror_vgroup_ensure(Object *ob, const int vgroup_active)
 		flip_side_name(name, defgroup->name, FALSE);
 
 		if (strcmp(name, defgroup->name) != 0) {
-			for (curdef= ob->defbase.first, mirrdef= 0; curdef; curdef=curdef->next, mirrdef++) {
+			for (curdef = ob->defbase.first, mirrdef = 0; curdef; curdef = curdef->next, mirrdef++) {
 				if (!strcmp(curdef->name, name)) {
 					break;
 				}
 			}
 
-			if (curdef==NULL) {
-				int olddef= ob->actdef;	/* tsk, ED_vgroup_add sets the active defgroup */
-				curdef= ED_vgroup_add_name(ob, name);
-				ob->actdef= olddef;
+			if (curdef == NULL) {
+				int olddef = ob->actdef;	/* tsk, ED_vgroup_add sets the active defgroup */
+				curdef = ED_vgroup_add_name(ob, name);
+				ob->actdef = olddef;
 			}
 
 			/* curdef should never be NULL unless this is
@@ -407,14 +407,14 @@ static void copy_vpaint_prev(VPaint *vp, unsigned int *lcol, int tot)
 {
 	if (vp->vpaint_prev) {
 		MEM_freeN(vp->vpaint_prev);
-		vp->vpaint_prev= NULL;
+		vp->vpaint_prev = NULL;
 	}
-	vp->tot= tot;	
+	vp->tot = tot;
 	
-	if (lcol==NULL || tot==0) return;
+	if (lcol == NULL || tot == 0) return;
 	
-	vp->vpaint_prev= MEM_mallocN(sizeof(int)*tot, "vpaint_prev");
-	memcpy(vp->vpaint_prev, lcol, sizeof(int)*tot);
+	vp->vpaint_prev = MEM_mallocN(sizeof(int) * tot, "vpaint_prev");
+	memcpy(vp->vpaint_prev, lcol, sizeof(int) * tot);
 	
 }
 
@@ -422,12 +422,12 @@ static void copy_wpaint_prev (VPaint *wp, MDeformVert *dverts, int dcount)
 {
 	if (wp->wpaint_prev) {
 		free_dverts(wp->wpaint_prev, wp->tot);
-		wp->wpaint_prev= NULL;
+		wp->wpaint_prev = NULL;
 	}
 	
 	if (dverts && dcount) {
 		
-		wp->wpaint_prev = MEM_mallocN (sizeof(MDeformVert)*dcount, "wpaint prev");
+		wp->wpaint_prev = MEM_mallocN (sizeof(MDeformVert) * dcount, "wpaint prev");
 		wp->tot = dcount;
 		copy_dverts (wp->wpaint_prev, dverts, dcount);
 	}
@@ -441,23 +441,23 @@ void vpaint_fill(Object *ob, unsigned int paintcol)
 	MLoopCol *lcol;
 	int i, j, selected;
 
-	me= get_mesh(ob);
-	if (me==NULL || me->totpoly==0) return;
+	me = get_mesh(ob);
+	if (me == NULL || me->totpoly == 0) return;
 
 	if (!me->mloopcol) make_vertexcol(ob);
 	if (!me->mloopcol) return; /* possible we can't make mcol's */
 
 
-	selected= (me->editflag & ME_EDIT_PAINT_MASK);
+	selected = (me->editflag & ME_EDIT_PAINT_MASK);
 
 	mp = me->mpoly;
-	for (i=0; i<me->totpoly; i++, mp++) {
+	for (i = 0; i < me->totpoly; i++, mp++) {
 		if (!(!selected || mp->flag & ME_FACE_SEL))
 			continue;
 
 		lcol = me->mloopcol + mp->loopstart;
-		for (j=0; j<mp->totloop; j++, lcol++) {
-			*(int*)lcol = paintcol;
+		for (j = 0; j < mp->totloop; j++, lcol++) {
+			*(int *)lcol = paintcol;
 		}
 	}
 	
@@ -471,74 +471,74 @@ void vpaint_fill(Object *ob, unsigned int paintcol)
 /* fills in the selected faces with the current weight and vertex group */
 void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
 {
-	Mesh *me= ob->data;
+	Mesh *me = ob->data;
 	MPoly *mf;
 	MDeformWeight *dw, *dw_prev;
-	int vgroup_active, vgroup_mirror= -1;
+	int vgroup_active, vgroup_mirror = -1;
 	unsigned int index;
 
 	/* mutually exclusive, could be made into a */
-	const short paint_selmode= ME_EDIT_PAINT_SEL_MODE(me);
+	const short paint_selmode = ME_EDIT_PAINT_SEL_MODE(me);
 
-	if (me->totpoly==0 || me->dvert==NULL || !me->mpoly) return;
+	if (me->totpoly == 0 || me->dvert == NULL || !me->mpoly) return;
 	
 	vgroup_active = ob->actdef - 1;
 
 	/* if mirror painting, find the other group */
 	if (me->editflag & ME_EDIT_MIRROR_X) {
-		vgroup_mirror= wpaint_mirror_vgroup_ensure(ob, vgroup_active);
+		vgroup_mirror = wpaint_mirror_vgroup_ensure(ob, vgroup_active);
 	}
 	
 	copy_wpaint_prev(wp, me->dvert, me->totvert);
 	
-	for (index=0, mf= me->mpoly; index < me->totpoly; index++, mf++) {
-		unsigned int fidx= mf->totloop - 1;
+	for (index = 0, mf = me->mpoly; index < me->totpoly; index++, mf++) {
+		unsigned int fidx = mf->totloop - 1;
 
 		if ((paint_selmode == SCE_SELECT_FACE) && !(mf->flag & ME_FACE_SEL)) {
 			continue;
 		}
 
 		do {
-			unsigned int vidx= me->mloop[mf->loopstart + fidx].v;
+			unsigned int vidx = me->mloop[mf->loopstart + fidx].v;
 
 			if (!me->dvert[vidx].flag) {
 				if ((paint_selmode == SCE_SELECT_VERTEX) && !(me->mvert[vidx].flag & SELECT)) {
 					continue;
 				}
 
-				dw= defvert_verify_index(&me->dvert[vidx], vgroup_active);
+				dw = defvert_verify_index(&me->dvert[vidx], vgroup_active);
 				if (dw) {
-					dw_prev= defvert_verify_index(wp->wpaint_prev+vidx, vgroup_active);
-					dw_prev->weight= dw->weight; /* set the undo weight */
-					dw->weight= paintweight;
+					dw_prev = defvert_verify_index(wp->wpaint_prev + vidx, vgroup_active);
+					dw_prev->weight = dw->weight; /* set the undo weight */
+					dw->weight = paintweight;
 
 					if (me->editflag & ME_EDIT_MIRROR_X) {	/* x mirror painting */
-						int j= mesh_get_x_mirror_vert(ob, vidx);
-						if (j>=0) {
+						int j = mesh_get_x_mirror_vert(ob, vidx);
+						if (j >= 0) {
 							/* copy, not paint again */
 							if (vgroup_mirror != -1) {
-								dw= defvert_verify_index(me->dvert+j, vgroup_mirror);
-								dw_prev= defvert_verify_index(wp->wpaint_prev+j, vgroup_mirror);
+								dw = defvert_verify_index(me->dvert + j, vgroup_mirror);
+								dw_prev = defvert_verify_index(wp->wpaint_prev + j, vgroup_mirror);
 							}
 							else {
-								dw= defvert_verify_index(me->dvert+j, vgroup_active);
-								dw_prev= defvert_verify_index(wp->wpaint_prev+j, vgroup_active);
+								dw = defvert_verify_index(me->dvert + j, vgroup_active);
+								dw_prev = defvert_verify_index(wp->wpaint_prev + j, vgroup_active);
 							}
-							dw_prev->weight= dw->weight; /* set the undo weight */
-							dw->weight= paintweight;
+							dw_prev->weight = dw->weight; /* set the undo weight */
+							dw->weight = paintweight;
 						}
 					}
 				}
-				me->dvert[vidx].flag= 1;
+				me->dvert[vidx].flag = 1;
 			}
 
 		} while (fidx--);
 	}
 
 	{
-		MDeformVert *dv= me->dvert;
-		for (index= me->totvert; index != 0; index--, dv++) {
-			dv->flag= 0;
+		MDeformVert *dv = me->dvert;
+		for (index = me->totvert; index != 0; index--, dv++) {
+			dv->flag = 0;
 		}
 	}
 
@@ -551,41 +551,41 @@ void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
 #if 0
 void vpaint_dogamma(Scene *scene)
 {
-	VPaint *vp= scene->toolsettings->vpaint;
+	VPaint *vp = scene->toolsettings->vpaint;
 	Mesh *me;
 	Object *ob;
 	float igam, fac;
 	int a, temp;
 	unsigned char *cp, gamtab[256];
 
-	ob= OBACT;
-	me= get_mesh(ob);
+	ob = OBACT;
+	me = get_mesh(ob);
 
 	if (!(ob->mode & OB_MODE_VERTEX_PAINT)) return;
-	if (me==0 || me->mcol==0 || me->totface==0) return;
+	if (me == 0 || me->mcol == 0 || me->totface == 0) return;
 
-	igam= 1.0/vp->gamma;
-	for (a=0; a<256; a++) {
+	igam = 1.0 / vp->gamma;
+	for (a = 0; a < 256; a++) {
 
-		fac= ((float)a)/255.0;
-		fac= vp->mul*pow( fac, igam);
+		fac = ((float)a) / 255.0;
+		fac = vp->mul * pow( fac, igam);
 
-		temp= 255.9*fac;
+		temp = 255.9 * fac;
 
-		if (temp<=0) gamtab[a]= 0;
-		else if (temp>=255) gamtab[a]= 255;
-		else gamtab[a]= temp;
+		if (temp <= 0) gamtab[a] = 0;
+		else if (temp >= 255) gamtab[a] = 255;
+		else gamtab[a] = temp;
 	}
 
-	a= 4*me->totface;
-	cp= (unsigned char *)me->mcol;
+	a = 4 * me->totface;
+	cp = (unsigned char *)me->mcol;
 	while (a--) {
 
-		cp[1]= gamtab[ cp[1] ];
-		cp[2]= gamtab[ cp[2] ];
-		cp[3]= gamtab[ cp[3] ];
+		cp[1] = gamtab[ cp[1] ];
+		cp[2] = gamtab[ cp[2] ];
+		cp[3] = gamtab[ cp[3] ];
 
-		cp+= 4;
+		cp += 4;
 	}
 }
 #endif
@@ -788,24 +788,24 @@ static unsigned int vpaint_blend(VPaint *vp, unsigned int col, unsigned int colo
 	col = vpaint_blend_tool(tool, col, paintcol, alpha_i);
 
 	/* if no spray, clip color adding with colorig & orig alpha */
-	if ((vp->flag & VP_SPRAY)==0) {
+	if ((vp->flag & VP_SPRAY) == 0) {
 		unsigned int testcol, a;
 		char *cp, *ct, *co;
 		
 		testcol = vpaint_blend_tool(tool, colorig, paintcol, brush_alpha_value_i);
 		
-		cp= (char *)&col;
-		ct= (char *)&testcol;
-		co= (char *)&colorig;
+		cp = (char *)&col;
+		ct = (char *)&testcol;
+		co = (char *)&colorig;
 		
-		for (a=0; a<4; a++) {
-			if ( ct[a]<co[a] ) {
-				if ( cp[a]<ct[a] ) cp[a]= ct[a];
-				else if ( cp[a]>co[a] ) cp[a]= co[a];
+		for (a = 0; a < 4; a++) {
+			if ( ct[a] < co[a] ) {
+				if ( cp[a] < ct[a] ) cp[a] = ct[a];
+				else if ( cp[a] > co[a] ) cp[a] = co[a];
 			}
 			else {
-				if ( cp[a]<co[a] ) cp[a]= co[a];
-				else if ( cp[a]>ct[a] ) cp[a]= ct[a];
+				if ( cp[a] < co[a] ) cp[a] = co[a];
+				else if ( cp[a] > ct[a] ) cp[a] = ct[a];
 			}
 		}
 	}
@@ -817,32 +817,32 @@ static unsigned int vpaint_blend(VPaint *vp, unsigned int col, unsigned int colo
 static int sample_backbuf_area(ViewContext *vc, int *indexar, int totface, int x, int y, float size)
 {
 	struct ImBuf *ibuf;
-	int a, tot=0, index;
+	int a, tot = 0, index;
 	
 	/* brecht: disabled this because it obviously fails for
 	 * brushes with size > 64, why is this here? */
-	/*if(size>64.0) size= 64.0;*/
+	/*if(size > 64.0) size = 64.0;*/
 	
-	ibuf= view3d_read_backbuf(vc, x-size, y-size, x+size, y+size);
+	ibuf = view3d_read_backbuf(vc, x - size, y - size, x + size, y + size);
 	if (ibuf) {
-		unsigned int *rt= ibuf->rect;
+		unsigned int *rt = ibuf->rect;
 
-		memset(indexar, 0, sizeof(int)*(totface+1));
+		memset(indexar, 0, sizeof(int) * (totface + 1));
 		
-		size= ibuf->x*ibuf->y;
+		size = ibuf->x * ibuf->y;
 		while (size--) {
 				
 			if (*rt) {
-				index= WM_framebuffer_to_index(*rt);
-				if (index>0 && index<=totface)
+				index = WM_framebuffer_to_index(*rt);
+				if (index > 0 && index <= totface)
 					indexar[index] = 1;
 			}
 		
 			rt++;
 		}
 		
-		for (a=1; a<=totface; a++) {
-			if (indexar[a]) indexar[tot++]= a;
+		for (a = 1; a <= totface; a++) {
+			if (indexar[a]) indexar[tot++] = a;
 		}
 
 		IMB_freeImBuf(ibuf);
@@ -861,7 +861,7 @@ static float calc_vp_strength_dl(VPaint *vp, ViewContext *vc, const float *vert_
 
 	project_float_noclip(vc->ar, vert_nor, vertco);
 	sub_v2_v2v2(delta, mval, vertco);
-	dist_squared= dot_v2v2(delta, delta); /* len squared */
+	dist_squared = dot_v2v2(delta, delta); /* len squared */
 	if (dist_squared > brush_size_pressure * brush_size_pressure) {
 		return 0.0f;
 	}
@@ -879,11 +879,11 @@ static float calc_vp_alpha_dl(VPaint *vp, ViewContext *vc,
 	float strength = calc_vp_strength_dl(vp, vc, vert_nor, mval, brush_size_pressure);
 
 	if (strength > 0.0f) {
-		float alpha= brush_alpha_pressure * strength;
+		float alpha = brush_alpha_pressure * strength;
 
 		if (vp->flag & VP_NORMALS) {
 			float dvec[3];
-			const float *no= vert_nor + 3;
+			const float *no = vert_nor + 3;
 
 			/* transpose ! */
 			dvec[2] = dot_v3v3(vpimat[2], no);
@@ -966,13 +966,13 @@ static float wpaint_blend(VPaint *wp, float weight, float weight_prev,
 			case PAINT_BLEND_MIX:
 				paintval = 1.f - paintval; break;
 			case PAINT_BLEND_ADD:
-				tool= PAINT_BLEND_SUB; break;
+				tool = PAINT_BLEND_SUB; break;
 			case PAINT_BLEND_SUB:
-				tool= PAINT_BLEND_ADD; break;
+				tool = PAINT_BLEND_ADD; break;
 			case PAINT_BLEND_LIGHTEN:
-				tool= PAINT_BLEND_DARKEN; break;
+				tool = PAINT_BLEND_DARKEN; break;
 			case PAINT_BLEND_DARKEN:
-				tool= PAINT_BLEND_LIGHTEN; break;
+				tool = PAINT_BLEND_LIGHTEN; break;
 		}
 	}
 	
@@ -1012,52 +1012,52 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
 	ViewContext vc;
 	Mesh *me;
-	short change= FALSE;
+	short change = FALSE;
 
 	view3d_set_viewcontext(C, &vc);
-	me= get_mesh(vc.obact);
+	me = get_mesh(vc.obact);
 
 	if (me && me->dvert && vc.v3d && vc.rv3d) {
 		int index;
 
 		view3d_operator_needs_opengl(C);
 
-		index= view3d_sample_backbuf(&vc, event->mval[0], event->mval[1]);
+		index = view3d_sample_backbuf(&vc, event->mval[0], event->mval[1]);
 
-		if (index && index<=me->totpoly) {
-			DerivedMesh *dm= mesh_get_derived_final(vc.scene, vc.obact, CD_MASK_BAREMESH);
+		if (index && index <= me->totpoly) {
+			DerivedMesh *dm = mesh_get_derived_final(vc.scene, vc.obact, CD_MASK_BAREMESH);
 
-			if (dm->getVertCo==NULL) {
+			if (dm->getVertCo == NULL) {
 				BKE_report(op->reports, RPT_WARNING, "The modifier used does not support deformed locations");
 			}
 			else {
-				MPoly *mf= ((MPoly *)me->mpoly) + index-1;
-				const int vgroup_active= vc.obact->actdef - 1;
-				ToolSettings *ts= vc.scene->toolsettings;
+				MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
+				const int vgroup_active = vc.obact->actdef - 1;
+				ToolSettings *ts = vc.scene->toolsettings;
 				float mval_f[2];
-				int v_idx_best= -1;
+				int v_idx_best = -1;
 				int fidx;
-				float len_best= FLT_MAX;
+				float len_best = FLT_MAX;
 
-				mval_f[0]= (float)event->mval[0];
-				mval_f[1]= (float)event->mval[1];
+				mval_f[0] = (float)event->mval[0];
+				mval_f[1] = (float)event->mval[1];
 
-				fidx= mf->totloop - 1;
+				fidx = mf->totloop - 1;
 				do {
 					float co[3], sco[3], len;
-					const int v_idx= me->mloop[mf->loopstart + fidx].v;
+					const int v_idx = me->mloop[mf->loopstart + fidx].v;
 					dm->getVertCo(dm, v_idx, co);
 					project_float_noclip(vc.ar, co, sco);
-					len= len_squared_v2v2(mval_f, sco);
+					len = len_squared_v2v2(mval_f, sco);
 					if (len < len_best) {
-						len_best= len;
-						v_idx_best= v_idx;
+						len_best = len;
+						v_idx_best = v_idx;
 					}
 				} while (fidx--);
 
 				if (v_idx_best != -1) { /* should always be valid */
-					ts->vgroup_weight= defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
-					change= TRUE;
+					ts->vgroup_weight = defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
+					change = TRUE;
 				}
 			}
 			dm->release(dm);
@@ -1093,59 +1093,59 @@ void PAINT_OT_weight_sample(wmOperatorType *ot)
 static EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
 {
 	if (C) {
-		wmWindow *win= CTX_wm_window(C);
+		wmWindow *win = CTX_wm_window(C);
 		if (win && win->eventstate) {
 			ViewContext vc;
 			Mesh *me;
 
 			view3d_set_viewcontext(C, &vc);
-			me= get_mesh(vc.obact);
+			me = get_mesh(vc.obact);
 
 			if (me && me->dvert && vc.v3d && vc.rv3d) {
 				int index;
 
 				view3d_operator_needs_opengl(C);
 
-				index= view3d_sample_backbuf(&vc, win->eventstate->x - vc.ar->winrct.xmin, win->eventstate->y - vc.ar->winrct.ymin);
+				index = view3d_sample_backbuf(&vc, win->eventstate->x - vc.ar->winrct.xmin, win->eventstate->y - vc.ar->winrct.ymin);
 
-				if (index && index<=me->totpoly) {
-					const int defbase_tot= BLI_countlist(&vc.obact->defbase);
+				if (index && index <= me->totpoly) {
+					const int defbase_tot = BLI_countlist(&vc.obact->defbase);
 					if (defbase_tot) {
-						MPoly *mf= ((MPoly *)me->mpoly) + index-1;
-						unsigned int fidx= mf->totloop - 1;
-						int *groups= MEM_callocN(defbase_tot*sizeof(int), "groups");
-						int found= FALSE;
+						MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
+						unsigned int fidx = mf->totloop - 1;
+						int *groups = MEM_callocN(defbase_tot * sizeof(int), "groups");
+						int found = FALSE;
 
 						do {
-							MDeformVert *dvert= me->dvert + me->mloop[mf->loopstart + fidx].v;
-							int i= dvert->totweight;
+							MDeformVert *dvert = me->dvert + me->mloop[mf->loopstart + fidx].v;
+							int i = dvert->totweight;
 							MDeformWeight *dw;
-							for (dw= dvert->dw; i > 0; dw++, i--) {
+							for (dw = dvert->dw; i > 0; dw++, i--) {
 								if (dw->def_nr < defbase_tot) {
-									groups[dw->def_nr]= TRUE;
-									found= TRUE;
+									groups[dw->def_nr] = TRUE;
+									found = TRUE;
 								}
 							}
 						} while (fidx--);
 
-						if (found==FALSE) {
+						if (found == FALSE) {
 							MEM_freeN(groups);
 						}
 						else {
-							EnumPropertyItem *item= NULL, item_tmp= {0};
-							int totitem= 0;
-							int i= 0;
+							EnumPropertyItem *item = NULL, item_tmp = {0};
+							int totitem = 0;
+							int i = 0;
 							bDeformGroup *dg;
-							for (dg= vc.obact->defbase.first; dg && i<defbase_tot; i++, dg= dg->next) {
+							for (dg = vc.obact->defbase.first; dg && i < defbase_tot; i++, dg = dg->next) {
 								if (groups[i]) {
-									item_tmp.identifier= item_tmp.name= dg->name;
-									item_tmp.value= i;
+									item_tmp.identifier = item_tmp.name = dg->name;
+									item_tmp.value = i;
 									RNA_enum_item_add(&item, &totitem, &item_tmp);
 								}
 							}
 
 							RNA_enum_item_end(&item, &totitem);
-							*free= 1;
+							*free = 1;
 
 							MEM_freeN(groups);
 							return item;
@@ -1161,12 +1161,12 @@ static EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C, PointerRNA
 
 static int weight_sample_group_exec(bContext *C, wmOperator *op)
 {
-	int type= RNA_enum_get(op->ptr, "group");
+	int type = RNA_enum_get(op->ptr, "group");
 	ViewContext vc;
 	view3d_set_viewcontext(C, &vc);
 
 	BLI_assert(type + 1 >= 0);
-	vc.obact->actdef= type + 1;
+	vc.obact->actdef = type + 1;
 
 	DAG_id_tag_update(&vc.obact->id, OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, vc.obact);
@@ -1176,7 +1176,7 @@ static int weight_sample_group_exec(bContext *C, wmOperator *op)
 /* TODO, we could make this a menu into OBJECT_OT_vertex_group_set_active rather than its own operator */
 void PAINT_OT_weight_sample_group(wmOperatorType *ot)
 {
-	PropertyRNA *prop= NULL;
+	PropertyRNA *prop = NULL;
 
 	/* identifiers */
 	ot->name = "Weight Paint Sample Group";
@@ -1191,18 +1191,18 @@ void PAINT_OT_weight_sample_group(wmOperatorType *ot)
 	ot->flag = OPTYPE_UNDO;
 
 	/* keyingset to use (dynamic enum) */
-	prop= RNA_def_enum(ot->srna, "group", DummyRNA_DEFAULT_items, 0, "Keying Set", "The Keying Set to use");
+	prop = RNA_def_enum(ot->srna, "group", DummyRNA_DEFAULT_items, 0, "Keying Set", "The Keying Set to use");
 	RNA_def_enum_funcs(prop, weight_paint_sample_enum_itemf);
 	ot->prop = prop;
 }
 
 static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_tot, const char *vgroup_validmap)
 {
-	float sum= 0.0f, fac;
-	unsigned int i, tot=0;
+	float sum = 0.0f, fac;
+	unsigned int i, tot = 0;
 	MDeformWeight *dw;
 
-	for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+	for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 		if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 			tot++;
 			sum += dw->weight;
@@ -1214,9 +1214,9 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
 	}
 
 	if (sum != 0.0f) {
-		fac= 1.0f / sum;
+		fac = 1.0f / sum;
 
-		for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+		for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 			if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 					dw->weight *= fac;
 			}
@@ -1226,7 +1226,7 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
 		/* hrmf, not a factor in this case */
 		fac = 1.0f / tot;
 
-		for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+		for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 			if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 				dw->weight = fac;
 			}
@@ -1241,12 +1241,12 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
 static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int defbase_tot, const char *vgroup_validmap,
                                                  const int vgroup_active)
 {
-	float sum= 0.0f, fac;
-	unsigned int i, tot=0;
+	float sum = 0.0f, fac;
+	unsigned int i, tot = 0;
 	MDeformWeight *dw;
 	float act_weight = 0.0f;
 
-	for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+	for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 		if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 			if (dw->def_nr != vgroup_active) {
 				sum += dw->weight;
@@ -1265,7 +1265,7 @@ static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int d
 	if (sum != 0.0f) {
 		fac = (1.0f / sum) * (1.0f - act_weight);
 
-		for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+		for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 			if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 				if (dw->def_nr != vgroup_active) {
 					dw->weight *= fac;
@@ -1285,7 +1285,7 @@ static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int d
 		/* paranoid but possibly with float error */
 		CLAMP(fac, 0.0f, 1.0f);
 
-		for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+		for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 			if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
 				if (dw->def_nr != vgroup_active) {
 					dw->weight = fac;
@@ -1304,7 +1304,7 @@ static char has_locked_group(MDeformVert *dvert, const int defbase_tot,
 	int i;
 	MDeformWeight *dw;
 
-	for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
+	for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
 		if (dw->def_nr < defbase_tot) {
 			if (bone_groups[dw->def_nr] && lock_flags[dw->def_nr] && dw->weight > 0.0f) {
 				return TRUE;
@@ -1317,12 +1317,12 @@ static char has_locked_group(MDeformVert *dvert, const int defbase_tot,
  * gen_lck_flags gets the status of "flag" for each bDeformGroup
  *in ob->defbase and returns an array containing them
  */
-static char *gen_lock_flags(Object* ob, int defbase_tot)
+static char *gen_lock_flags(Object *ob, int defbase_tot)
 {
 	char is_locked = FALSE;
 	int i;
 	//int defbase_tot = BLI_countlist(&ob->defbase);
-	char *lock_flags = MEM_mallocN(defbase_tot*sizeof(char), "defflags");
+	char *lock_flags = MEM_mallocN(defbase_tot * sizeof(char), "defflags");
 	bDeformGroup *defgroup;
 
 	for (i = 0, defgroup = ob->defbase.first; i < defbase_tot && defgroup; defgroup = defgroup->next, i++) {
@@ -1381,7 +1381,7 @@ static void multipaint_selection(MDeformVert *dvert, const int defbase_tot, floa
 					/* TODO: when the change is reduced, you need to recheck
 					 * the earlier values to make sure they are not 0
 					 * (precision error) */
-					change = 1.0f/dw->weight;
+					change = 1.0f / dw->weight;
 				}
 				/* the value should never reach zero while multi-painting if it
 				 * was nonzero beforehand */
@@ -1419,9 +1419,9 @@ static float redistribute_change(MDeformVert *ndv, const int defbase_tot,
 		/* assume there is no change until you see one */
 		was_change = FALSE;
 		/* change each group by the same amount each time */
-		change = totchange/total_valid;
+		change = totchange / total_valid;
 		for (i = 0; i < ndv->totweight && total_valid && totchange; i++) {
-			ndw = (ndv->dw+i);
+			ndw = (ndv->dw + i);
 
 			/* ignore anything outside the value range */
 			if (ndw->def_nr < defbase_tot) {
@@ -1431,8 +1431,8 @@ static float redistribute_change(MDeformVert *ndv, const int defbase_tot,
 					oldval = ndw->weight;
 					/* if auto normalize is active, don't worry about upper bounds */
 					if (do_auto_normalize == FALSE && ndw->weight + change > 1) {
-						totchange -= 1-ndw->weight;
-						ndw->weight = 1;
+						totchange -= 1.0f - ndw->weight;
+						ndw->weight = 1.0f;
 						/* stop the changes to this group */
 						change_status[ndw->def_nr] = changeto;
 						total_valid--;
@@ -1487,7 +1487,7 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
 		return;
 	}
 	/* record if a group was changed, unlocked and not changed, or locked */
-	change_status = MEM_callocN(sizeof(char)*defbase_tot, "unlocked_unchanged");
+	change_status = MEM_callocN(sizeof(char) * defbase_tot, "unlocked_unchanged");
 
 	for (i = 0; i < defbase_tot; i++) {
 		ndw = defvert_find_index(ndv, i);
@@ -1524,7 +1524,7 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
 		if (vgroup_validmap && total_changed < 0 && total_valid) {
 			totchange_allowed = total_valid;
 		}
-		/* the way you modify the unlocked+unchanged groups is different depending
+		/* the way you modify the unlocked + unchanged groups is different depending
 		 * on whether or not you are painting the weight(s) up or down */
 		if (totchange < 0) {
 			totchange_allowed = total_valid - totchange_allowed;
@@ -1564,11 +1564,11 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
 		else {
 			/* reset the weights */
 			unsigned int i;
-			MDeformWeight *dw_old= odv->dw;
-			MDeformWeight *dw_new= ndv->dw;
+			MDeformWeight *dw_old = odv->dw;
+			MDeformWeight *dw_new = ndv->dw;
 
-			for (i= odv->totweight; i != 0; i--, dw_old++, dw_new++) {
-				dw_new->weight= dw_old->weight;
+			for (i = odv->totweight; i != 0; i--, dw_old++, dw_new++) {
+				dw_new->weight = dw_old->weight;
 			}
 		}
 	}
@@ -1581,17 +1581,17 @@ static float get_mp_change(MDeformVert *odv, const int defbase_tot, const char *
 {
 	float selwsum = 0.0f;
 	unsigned int i;
-	MDeformWeight *dw= odv->dw;
+	MDeformWeight *dw = odv->dw;
 
-	for (i= odv->totweight; i != 0; i--, dw++) {
+	for (i = odv->totweight; i != 0; i--, dw++) {
 		if (dw->def_nr < defbase_tot) {
 			if (defbase_sel[dw->def_nr]) {
 				selwsum += dw->weight;
 			}
 		}
 	}
-	if (selwsum && selwsum+brush_change > 0) {
-		return (selwsum+brush_change)/selwsum;
+	if (selwsum && selwsum + brush_change > 0) {
+		return (selwsum + brush_change) / selwsum;
 	}
 	return 0.0f;
 }
@@ -1600,11 +1600,11 @@ static float get_mp_change(MDeformVert *odv, const int defbase_tot, const char *
  * it assumes you already have the correct pointer index */
 static void defvert_reset_to_prev(MDeformVert *dv_prev, MDeformVert *dv)
 {
-	MDeformWeight *dw= dv->dw;
+	MDeformWeight *dw = dv->dw;
 	MDeformWeight *dw_prev;
 	unsigned int i;
-	for (i= dv->totweight; i != 0; i--, dw++) {
-		dw_prev= defvert_find_index(dv_prev, dw->def_nr);
+	for (i = dv->totweight; i != 0; i--, dw++) {
+		dw_prev = defvert_find_index(dv_prev, dw->def_nr);
 		/* if there was no w when there is a d, then the old weight was 0 */
 		dw->weight = dw_prev ? dw_prev->weight : 0.0f;
 	}
@@ -1612,9 +1612,9 @@ static void defvert_reset_to_prev(MDeformVert *dv_prev, MDeformVert *dv)
 
 static void clamp_weights(MDeformVert *dvert)
 {
-	MDeformWeight *dw= dvert->dw;
+	MDeformWeight *dw = dvert->dw;
 	unsigned int i;
-	for (i= dvert->totweight; i != 0; i--, dw++) {
+	for (i = dvert->totweight; i != 0; i--, dw++) {
 		CLAMP(dw->weight, 0.0f, 1.0f);
 	}
 }
@@ -1661,10 +1661,10 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
                                     float change, float oldChange,
                                     float oldw, float neww)
 {
-	MDeformVert *dv= &me->dvert[index];
-	MDeformVert dv_test= {NULL};
+	MDeformVert *dv = &me->dvert[index];
+	MDeformVert dv_test = {NULL};
 
-	dv_test.dw= MEM_dupallocN(dv->dw);
+	dv_test.dw = MEM_dupallocN(dv->dw);
 	dv_test.flag = dv->flag;
 	dv_test.totweight = dv->totweight;
 	/* do not multi-paint if a locked group is selected or the active group is locked
@@ -1674,7 +1674,7 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
 	      has_locked_group_selected(wpi->defbase_tot, wpi->defbase_sel, wpi->lock_flags) == FALSE))
 	{
 		if (wpi->do_multipaint && wpi->defbase_tot_sel > 1) {
-			if (change && change!=1) {
+			if (change && change != 1) {
 				multipaint_selection(dv, wpi->defbase_tot, change, wpi->defbase_sel);
 			}
 		}
@@ -1716,8 +1716,8 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
 static int get_first_selected_nonzero_weight(MDeformVert *dvert, const int defbase_tot, const char *defbase_sel)
 {
 	int i;
-	MDeformWeight *dw= dvert->dw;
-	for (i=0; i< dvert->totweight; i++, dw++) {
+	MDeformWeight *dw = dvert->dw;
+	for (i = 0; i < dvert->totweight; i++, dw++) {
 		if (dw->def_nr < defbase_tot) {
 			if (defbase_sel[dw->def_nr] && dw->weight > 0.0f) {
 				return i;
@@ -1737,8 +1737,8 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
                                    const unsigned int index, float alpha, float paintweight
                                    )
 {
-	Mesh *me= ob->data;
-	MDeformVert *dv= &me->dvert[index];
+	Mesh *me = ob->data;
+	MDeformVert *dv = &me->dvert[index];
 	
 	MDeformWeight *dw, *dw_prev;
 
@@ -1752,15 +1752,15 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 	const short do_multipaint_totsel = (wpi->do_multipaint && wpi->defbase_tot_sel > 1);
 
 	if (wp->flag & VP_ONLYVGROUP) {
-		dw= defvert_find_index(dv, wpi->vgroup_active);
-		dw_prev= defvert_find_index(wp->wpaint_prev+index, wpi->vgroup_active);
+		dw = defvert_find_index(dv, wpi->vgroup_active);
+		dw_prev = defvert_find_index(wp->wpaint_prev + index, wpi->vgroup_active);
 	}
 	else {
-		dw= defvert_verify_index(dv, wpi->vgroup_active);
-		dw_prev= defvert_verify_index(wp->wpaint_prev+index, wpi->vgroup_active);
+		dw = defvert_verify_index(dv, wpi->vgroup_active);
+		dw_prev = defvert_verify_index(wp->wpaint_prev + index, wpi->vgroup_active);
 	}
 
-	if (dw==NULL || dw_prev==NULL) {
+	if (dw == NULL || dw_prev == NULL) {
 		return;
 	}
 
@@ -1881,12 +1881,12 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 		/* use locks and/or multipaint */
 		float oldw;
 		float neww;
-		float testw=0;
+		float testw = 0;
 		float change = 0;
 		float oldChange = 0;
 		int i;
 		MDeformWeight *tdw = NULL, *tdw_prev;
-		MDeformVert dv_copy= {NULL};
+		MDeformVert dv_copy = {NULL};
 
 		oldw = dw->weight;
 		neww = wpaint_blend(wp, dw->weight, dw_prev->weight, alpha, paintweight,
@@ -1894,7 +1894,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 		
 		/* setup multi-paint */
 		if (do_multipaint_totsel) {
-			dv_copy.dw= MEM_dupallocN(dv->dw);
+			dv_copy.dw = MEM_dupallocN(dv->dw);
 			dv_copy.flag = dv->flag;
 			dv_copy.totweight = dv->totweight;
 			tdw = dw;
@@ -1903,7 +1903,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 			if (change) {
 				if (!tdw->weight) {
 					i = get_first_selected_nonzero_weight(dv, wpi->defbase_tot, wpi->defbase_sel);
-					if (i>=0) {
+					if (i >= 0) {
 						tdw = &(dv->dw[i]);
 						tdw_prev = defvert_verify_index(&wp->wpaint_prev[index], tdw->def_nr);
 					}
@@ -1913,12 +1913,12 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 				}
 				if (change && tdw_prev->weight && tdw_prev->weight * change) {
 					if (tdw->weight != tdw_prev->weight) {
-						oldChange = tdw->weight/tdw_prev->weight;
-						testw = tdw_prev->weight*change;
+						oldChange = tdw->weight / tdw_prev->weight;
+						testw = tdw_prev->weight * change;
 						if ( testw > tdw_prev->weight ) {
 							if (change > oldChange) {
 								/* reset the weights and use the new change */
-								defvert_reset_to_prev(wp->wpaint_prev+index, dv);
+								defvert_reset_to_prev(wp->wpaint_prev + index, dv);
 							}
 							else {
 								/* the old change was more significant, so set
@@ -1928,7 +1928,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 						}
 						else {
 							if (change < oldChange) {
-								defvert_reset_to_prev(wp->wpaint_prev+index, dv);
+								defvert_reset_to_prev(wp->wpaint_prev + index, dv);
 							}
 							else {
 								change = 0;
@@ -1974,13 +1974,13 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
 
 static int set_wpaint(bContext *C, wmOperator *UNUSED(op))		/* toggle */
 {		
-	Object *ob= CTX_data_active_object(C);
-	Scene *scene= CTX_data_scene(C);
-	VPaint *wp= scene->toolsettings->wpaint;
+	Object *ob = CTX_data_active_object(C);
+	Scene *scene = CTX_data_scene(C);
+	VPaint *wp = scene->toolsettings->wpaint;
 	Mesh *me;
 	
-	me= get_mesh(ob);
-	if (ob->id.lib || me==NULL) return OPERATOR_PASS_THROUGH;
+	me = get_mesh(ob);
+	if (ob->id.lib || me == NULL) return OPERATOR_PASS_THROUGH;
 	
 	if (ob->mode & OB_MODE_WEIGHT_PAINT) ob->mode &= ~OB_MODE_WEIGHT_PAINT;
 	else ob->mode |= OB_MODE_WEIGHT_PAINT;
@@ -1996,8 +1996,8 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op))		/* toggle */
 	if (ob->mode & OB_MODE_WEIGHT_PAINT) {
 		Object *par;
 		
-		if (wp==NULL)
-			wp= scene->toolsettings->wpaint= new_vpaint(1);
+		if (wp == NULL)
+			wp = scene->toolsettings->wpaint = new_vpaint(1);
 
 		paint_init(&wp->paint, PAINT_CURSOR_WEIGHT_PAINT);
 		paint_cursor_start(C, weight_paint_poll);
@@ -2005,9 +2005,9 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op))		/* toggle */
 		mesh_octree_table(ob, NULL, NULL, 's');
 		
 		/* verify if active weight group is also active bone */
-		par= modifiers_isDeformedByArmature(ob);
+		par = modifiers_isDeformedByArmature(ob);
 		if (par && (par->mode & OB_MODE_POSE)) {
-			bArmature *arm= par->data;
+			bArmature *arm = par->data;
 
 			if (arm->act_bone)
 				ED_vgroup_select_by_name(ob, arm->act_bone->name);
@@ -2026,10 +2026,10 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op))		/* toggle */
 /* for switching to/from mode */
 static int paint_poll_test(bContext *C)
 {
-	Object *ob= CTX_data_active_object(C);
+	Object *ob = CTX_data_active_object(C);
 	if (CTX_data_edit_object(C))
 		return 0;
-	if (CTX_data_active_object(C)==NULL)
+	if (CTX_data_active_object(C) == NULL)
 		return 0;
 	if (!ob->data || ((ID *)ob->data)->lib)
 		return 0;
@@ -2062,8 +2062,8 @@ struct WPaintData {
 	float *vertexcosnos;
 	float wpimat[3][3];
 	
-	/*variables for auto normalize*/
-	const char *vgroup_validmap; /*stores if vgroups tie to deforming bones or not*/
+	/* variables for auto normalize */
+	const char *vgroup_validmap; /* stores if vgroups tie to deforming bones or not */
 	const char *lock_flags;
 	int defbase_tot;
 };
@@ -2074,32 +2074,32 @@ static char *wpaint_make_validmap(Object *ob)
 	ModifierData *md;
 	char *vgroup_validmap;
 	GHash *gh;
-	int i, step1=1;
+	int i, step1 = 1;
 
 	if (ob->defbase.first == NULL) {
 		return NULL;
 	}
 
-	gh= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "wpaint_make_validmap gh");
+	gh = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "wpaint_make_validmap gh");
 
-	/*add all names to a hash table*/
-	for (dg=ob->defbase.first; dg; dg=dg->next) {
+	/* add all names to a hash table */
+	for (dg = ob->defbase.first; dg; dg = dg->next) {
 		BLI_ghash_insert(gh, dg->name, NULL);
 	}
 
-	/*now loop through the armature modifiers and identify deform bones*/
-	for (md = ob->modifiers.first; md; md= !md->next && step1 ? (step1=0), modifiers_getVirtualModifierList(ob) : md->next) {
+	/* now loop through the armature modifiers and identify deform bones */
+	for (md = ob->modifiers.first; md; md = !md->next && step1 ? (step1 = 0), modifiers_getVirtualModifierList(ob) : md->next) {
 		if (!(md->mode & (eModifierMode_Realtime|eModifierMode_Virtual)))
 			continue;
 
 		if (md->type == eModifierType_Armature) {
-			ArmatureModifierData *amd= (ArmatureModifierData*) md;
+			ArmatureModifierData *amd = (ArmatureModifierData *) md;
 
 			if (amd->object && amd->object->pose) {
-				bPose *pose= amd->object->pose;
+				bPose *pose = amd->object->pose;
 				bPoseChannel *chan;
 				
-				for (chan=pose->chanbase.first; chan; chan=chan->next) {
+				for (chan = pose->chanbase.first; chan; chan = chan->next) {
 					if (chan->bone->flag & BONE_NO_DEFORM)
 						continue;
 
@@ -2112,11 +2112,11 @@ static char *wpaint_make_validmap(Object *ob)
 		}
 	}
 
-	vgroup_validmap= MEM_mallocN(BLI_ghash_size(gh), "wpaint valid map");
+	vgroup_validmap = MEM_mallocN(BLI_ghash_size(gh), "wpaint valid map");
 
-	/*add all names to a hash table*/
-	for (dg=ob->defbase.first, i=0; dg; dg=dg->next, i++) {
-		vgroup_validmap[i]= (BLI_ghash_lookup(gh, dg->name) != NULL);
+	/* add all names to a hash table */
+	for (dg = ob->defbase.first, i = 0; dg; dg = dg->next, i++) {
+		vgroup_validmap[i] = (BLI_ghash_lookup(gh, dg->name) != NULL);
 	}
 
 	BLI_assert(i == BLI_ghash_size(gh));
@@ -2128,11 +2128,11 @@ static char *wpaint_make_validmap(Object *ob)
 
 static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 {
-	Scene *scene= CTX_data_scene(C);
+	Scene *scene = CTX_data_scene(C);
 	struct PaintStroke *stroke = op->customdata;
-	ToolSettings *ts= scene->toolsettings;
-	VPaint *wp= ts->wpaint;
-	Object *ob= CTX_data_active_object(C);
+	ToolSettings *ts = scene->toolsettings;
+	VPaint *wp = ts->wpaint;
+	Object *ob = CTX_data_active_object(C);
 	struct WPaintData *wpd;
 	Mesh *me;
 	bDeformGroup *dg;
@@ -2143,8 +2143,8 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 		return FALSE;
 	}
 	
-	me= get_mesh(ob);
-	if (me==NULL || me->totpoly==0) return OPERATOR_PASS_THROUGH;
+	me = get_mesh(ob);
+	if (me == NULL || me->totpoly == 0) return OPERATOR_PASS_THROUGH;
 	
 	/* if nothing was added yet, we make dverts and a vertex deform group */
 	if (!me->dvert) {
@@ -2156,25 +2156,25 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 	if (ob->actdef <= 0) {
 		Object *modob;
 		if ((modob = modifiers_isDeformedByArmature(ob))) {
-			Bone *actbone= ((bArmature *)modob->data)->act_bone;
+			Bone *actbone = ((bArmature *)modob->data)->act_bone;
 			if (actbone) {
-				bPoseChannel *pchan= get_pose_channel(modob->pose, actbone->name);
+				bPoseChannel *pchan = get_pose_channel(modob->pose, actbone->name);
 
 				if (pchan) {
-					bDeformGroup *dg= defgroup_find_name(ob, pchan->name);
-					if (dg==NULL) {
-						dg= ED_vgroup_add_name(ob, pchan->name);	/* sets actdef */
+					bDeformGroup *dg = defgroup_find_name(ob, pchan->name);
+					if (dg == NULL) {
+						dg = ED_vgroup_add_name(ob, pchan->name);	/* sets actdef */
 					}
 					else {
 						int actdef = 1 + BLI_findindex(&ob->defbase, dg);
 						BLI_assert(actdef >= 0);
-						ob->actdef= actdef;
+						ob->actdef = actdef;
 					}
 				}
 			}
 		}
 	}
-	if (ob->defbase.first==NULL) {
+	if (ob->defbase.first == NULL) {
 		ED_vgroup_add(ob);
 	}
 
@@ -2186,7 +2186,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 
 	/* check if we are attempting to paint onto a locked vertex group,
 	 * and other options disallow it from doing anything useful */
-	dg = BLI_findlink(&ob->defbase, (ob->actdef-1));
+	dg = BLI_findlink(&ob->defbase, (ob->actdef - 1));
 	if (dg->flag & DG_LOCK_WEIGHT) {
 		BKE_report(op->reports, RPT_WARNING, "Active group is locked, aborting");
 		return FALSE;
@@ -2194,7 +2194,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 
 	/* ALLOCATIONS! no return after this line */
 	/* make mode data storage */
-	wpd= MEM_callocN(sizeof(struct WPaintData), "WPaintData");
+	wpd = MEM_callocN(sizeof(struct WPaintData), "WPaintData");
 	paint_stroke_set_mode_data(stroke, wpd);
 	view3d_set_viewcontext(C, &wpd->vc);
 
@@ -2202,7 +2202,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 	wpd->vgroup_mirror = -1;
 
 	/* set up auto-normalize, and generate map for detecting which
-	 * vgroups affect deform bones*/
+	 * vgroups affect deform bones */
 	wpd->defbase_tot = BLI_countlist(&ob->defbase);
 	wpd->lock_flags = gen_lock_flags(ob, wpd->defbase_tot);
 	if (ts->auto_normalize || ts->multipaint || wpd->lock_flags) {
@@ -2210,8 +2210,8 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 	}
 
 	/* painting on subsurfs should give correct points too, this returns me->totvert amount */
-	wpd->vertexcosnos= mesh_get_mapped_verts_nors(scene, ob);
-	wpd->indexar= get_indexarray(me);
+	wpd->vertexcosnos = mesh_get_mapped_verts_nors(scene, ob);
+	wpd->indexar = get_indexarray(me);
 	copy_wpaint_prev(wp, me->dvert, me->totvert);
 
 	/* imat for normals */
@@ -2229,11 +2229,11 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
 
 static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
 {
-	Scene *scene= CTX_data_scene(C);
-	ToolSettings *ts= CTX_data_tool_settings(C);
-	VPaint *wp= ts->wpaint;
+	Scene *scene = CTX_data_scene(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	VPaint *wp = ts->wpaint;
 	Brush *brush = paint_brush(&wp->paint);
-	struct WPaintData *wpd= paint_stroke_mode_data(stroke);
+	struct WPaintData *wpd = paint_stroke_mode_data(stroke);
 	ViewContext *vc;
 	Object *ob;
 	Mesh *me;
@@ -2263,10 +2263,10 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 		return;
 	}
 		
-	vc= &wpd->vc;
-	ob= vc->obact;
-	me= ob->data;
-	indexar= wpd->indexar;
+	vc = &wpd->vc;
+	ob = vc->obact;
+	me = ob->data;
+	indexar = wpd->indexar;
 	
 	view3d_operator_needs_opengl(C);
 		
@@ -2274,93 +2274,93 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	mult_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
 
 	RNA_float_get_array(itemptr, "mouse", mval);
-	mval[0]-= vc->ar->winrct.xmin;
-	mval[1]-= vc->ar->winrct.ymin;
+	mval[0] -= vc->ar->winrct.xmin;
+	mval[1] -= vc->ar->winrct.ymin;
 
 
 
 	/* *** setup WeightPaintInfo - pass onto do_weight_paint_vertex *** */
-	wpi.defbase_tot=        wpd->defbase_tot;
-	defbase_sel=            MEM_mallocN(wpi.defbase_tot*sizeof(char), "wpi.defbase_sel");
-	wpi.defbase_tot_sel=    get_selected_defgroups(ob, defbase_sel, wpi.defbase_tot);
-	wpi.defbase_sel=        defbase_sel; /* so we can stay const */
+	wpi.defbase_tot =        wpd->defbase_tot;
+	defbase_sel =            MEM_mallocN(wpi.defbase_tot * sizeof(char), "wpi.defbase_sel");
+	wpi.defbase_tot_sel =    get_selected_defgroups(ob, defbase_sel, wpi.defbase_tot);
+	wpi.defbase_sel =        defbase_sel; /* so we can stay const */
 	if (wpi.defbase_tot_sel == 0 && ob->actdef > 0) wpi.defbase_tot_sel = 1;
 
-	wpi.defbase_tot_unsel=  wpi.defbase_tot - wpi.defbase_tot_sel;
-	wpi.vgroup_active=      wpd->vgroup_active;
-	wpi.vgroup_mirror=      wpd->vgroup_mirror;
-	wpi.lock_flags=         wpd->lock_flags;
-	wpi.vgroup_validmap=    wpd->vgroup_validmap;
-	wpi.do_flip=            RNA_boolean_get(itemptr, "pen_flip");
-	wpi.do_multipaint=      (ts->multipaint != 0);
-	wpi.do_auto_normalize=	((ts->auto_normalize != 0) && (wpi.vgroup_validmap != NULL));
-	wpi.brush_alpha_value=  brush_alpha_value;
+	wpi.defbase_tot_unsel =  wpi.defbase_tot - wpi.defbase_tot_sel;
+	wpi.vgroup_active =      wpd->vgroup_active;
+	wpi.vgroup_mirror =      wpd->vgroup_mirror;
+	wpi.lock_flags =         wpd->lock_flags;
+	wpi.vgroup_validmap =    wpd->vgroup_validmap;
+	wpi.do_flip =            RNA_boolean_get(itemptr, "pen_flip");
+	wpi.do_multipaint =      (ts->multipaint != 0);
+	wpi.do_auto_normalize =  ((ts->auto_normalize != 0) && (wpi.vgroup_validmap != NULL));
+	wpi.brush_alpha_value =  brush_alpha_value;
 	/* *** done setting up WeightPaintInfo *** */
 
 
 
 	swap_m4m4(wpd->vc.rv3d->persmat, mat);
 
-	use_vert_sel= (me->editflag & ME_EDIT_VERT_SEL) != 0;
+	use_vert_sel = (me->editflag & ME_EDIT_VERT_SEL) != 0;
 
 	/* which faces are involved */
 	if (wp->flag & VP_AREA) {
 		/* Ugly hack, to avoid drawing vertex index when getting the face index buffer - campbell */
 		me->editflag &= ~ME_EDIT_VERT_SEL;
-		totindex= sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
+		totindex = sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
 		me->editflag |= use_vert_sel ? ME_EDIT_VERT_SEL : 0;
 	}
 	else {
-		indexar[0]= view3d_sample_backbuf(vc, mval[0], mval[1]);
-		if (indexar[0]) totindex= 1;
-		else totindex= 0;
+		indexar[0] = view3d_sample_backbuf(vc, mval[0], mval[1]);
+		if (indexar[0]) totindex = 1;
+		else totindex = 0;
 	}
 			
 	if (wp->flag & VP_COLINDEX) {
-		for (index=0; index<totindex; index++) {
-			if (indexar[index] && indexar[index]<=me->totpoly) {
-				MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
+		for (index = 0; index < totindex; index++) {
+			if (indexar[index] && indexar[index] <= me->totpoly) {
+				MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
 						
-				if (mpoly->mat_nr!=ob->actcol-1) {
-					indexar[index]= 0;
+				if (mpoly->mat_nr != ob->actcol - 1) {
+					indexar[index] = 0;
 				}
 			}
 		}
 	}
 			
 	if ((me->editflag & ME_EDIT_PAINT_MASK) && me->mpoly) {
-		for (index=0; index<totindex; index++) {
-			if (indexar[index] && indexar[index]<=me->totpoly) {
-				MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
+		for (index = 0; index < totindex; index++) {
+			if (indexar[index] && indexar[index] <= me->totpoly) {
+				MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
 						
-				if ((mpoly->flag & ME_FACE_SEL)==0) {
-					indexar[index]= 0;
+				if ((mpoly->flag & ME_FACE_SEL) == 0) {
+					indexar[index] = 0;
 				}
-			}					
+			}
 		}
 	}
-			
+
 	/* make sure each vertex gets treated only once */
 	/* and calculate filter weight */
-	totw= 0.0f;
+	totw = 0.0f;
 	if (brush->vertexpaint_tool == PAINT_BLEND_BLUR)
-		paintweight= 0.0f;
+		paintweight = 0.0f;
 	else
-		paintweight= ts->vgroup_weight;
+		paintweight = ts->vgroup_weight;
 			
-	for (index=0; index<totindex; index++) {
-		if (indexar[index] && indexar[index]<=me->totpoly) {
-			MPoly *mpoly= me->mpoly + (indexar[index]-1);
+	for (index = 0; index < totindex; index++) {
+		if (indexar[index] && indexar[index] <= me->totpoly) {
+			MPoly *mpoly = me->mpoly + (indexar[index] - 1);
 			MLoop *ml = me->mloop + mpoly->loopstart;
 			int i;
 
 			if (use_vert_sel) {
-				for (i=0; i<mpoly->totloop; i++, ml++) {
+				for (i = 0; i < mpoly->totloop; i++, ml++) {
 					me->dvert[ml->v].flag = (me->mvert[ml->v].flag & SELECT);
 				}
 			}
 			else {
-				for (i=0; i<mpoly->totloop; i++, ml++) {
+				for (i = 0; i < mpoly->totloop; i++, ml++) {
 					me->dvert[ml->v].flag = 1;
 				}
 			}
@@ -2369,14 +2369,14 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 				MDeformWeight *dw, *(*dw_func)(MDeformVert *, const int);
 						
 				if (wp->flag & VP_ONLYVGROUP)
-					dw_func= (MDeformWeight *(*)(MDeformVert *, const int))defvert_find_index;
+					dw_func = (MDeformWeight *(*)(MDeformVert *, const int))defvert_find_index;
 				else
-					dw_func= defvert_verify_index;
+					dw_func = defvert_verify_index;
 						
 				ml = me->mloop + mpoly->loopstart;
-				for (i=0; i<mpoly->totloop; i++, ml++) {
-					unsigned int vidx= ml->v;
-					const float fac = calc_vp_strength_dl(wp, vc, wpd->vertexcosnos+6*vidx, mval, brush_size_pressure);
+				for (i = 0; i < mpoly->totloop; i++, ml++) {
+					unsigned int vidx = ml->v;
+					const float fac = calc_vp_strength_dl(wp, vc, wpd->vertexcosnos + 6 * vidx, mval, brush_size_pressure);
 					if (fac > 0.0f) {
 						dw = dw_func(&me->dvert[vidx], wpi.vgroup_active);
 						paintweight += dw ? (dw->weight * fac) : 0.0f;
@@ -2391,23 +2391,23 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 		paintweight /= totw;
 	}
 
-	for (index=0; index<totindex; index++) {
+	for (index = 0; index < totindex; index++) {
 
-		if (indexar[index] && indexar[index]<=me->totpoly) {
-			MPoly *mpoly= me->mpoly + (indexar[index]-1);
-			MLoop *ml=me->mloop+mpoly->loopstart;
+		if (indexar[index] && indexar[index] <= me->totpoly) {
+			MPoly *mpoly = me->mpoly + (indexar[index] - 1);
+			MLoop *ml = me->mloop + mpoly->loopstart;
 			int i;
 
-			for (i=0; i<mpoly->totloop; i++, ml++) {
-				unsigned int vidx= ml->v;
+			for (i = 0; i < mpoly->totloop; i++, ml++) {
+				unsigned int vidx = ml->v;
 
 				if (me->dvert[vidx].flag) {
-					alpha= calc_vp_alpha_dl(wp, vc, wpd->wpimat, wpd->vertexcosnos+6*vidx,
+					alpha = calc_vp_alpha_dl(wp, vc, wpd->wpimat, wpd->vertexcosnos + 6 * vidx,
 					                        mval, brush_size_pressure, brush_alpha_pressure);
 					if (alpha) {
 						do_weight_paint_vertex(wp, ob, &wpi, vidx, alpha, paintweight);
 					}
-					me->dvert[vidx].flag= 0;
+					me->dvert[vidx].flag = 0;
 				}
 			}
 		}
@@ -2427,9 +2427,9 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 
 static void wpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
 {
-	ToolSettings *ts= CTX_data_tool_settings(C);
-	Object *ob= CTX_data_active_object(C);
-	struct WPaintData *wpd= paint_stroke_mode_data(stroke);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	Object *ob = CTX_data_active_object(C);
+	struct WPaintData *wpd = paint_stroke_mode_data(stroke);
 	
 	if (wpd) {
 		if (wpd->vertexcosnos)
@@ -2452,9 +2452,9 @@ static void wpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
 		ParticleSystem *psys;
 		int i;
 		
-		for (psys= ob->particlesystem.first; psys; psys= psys->next) {
-			for (i=0; i<PSYS_TOT_VG; i++) {
-				if (psys->vgroup[i]==ob->actdef) {
+		for (psys = ob->particlesystem.first; psys; psys = psys->next) {
+			for (i = 0; i < PSYS_TOT_VG; i++) {
+				if (psys->vgroup[i] == ob->actdef) {
 					psys->recalc |= PSYS_RECALC_RESET;
 					break;
 				}
@@ -2510,7 +2510,7 @@ void PAINT_OT_weight_paint(wmOperatorType *ot)
 
 static int weight_paint_set_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	struct Scene *scene= CTX_data_scene(C);
+	struct Scene *scene = CTX_data_scene(C);
 	Object *obact = CTX_data_active_object(C);
 
 	wpaint_fill(scene->toolsettings->wpaint, obact, scene->toolsettings->vgroup_weight);
@@ -2537,19 +2537,21 @@ void PAINT_OT_weight_set(wmOperatorType *ot)
 
 static int set_vpaint(bContext *C, wmOperator *op)		/* toggle */
 {	
-	Object *ob= CTX_data_active_object(C);
-	Scene *scene= CTX_data_scene(C);
-	VPaint *vp= scene->toolsettings->vpaint;
+	Object *ob = CTX_data_active_object(C);
+	Scene *scene = CTX_data_scene(C);
+	VPaint *vp = scene->toolsettings->vpaint;
 	Mesh *me;
 	
-	me= get_mesh(ob);
+	me = get_mesh(ob);
 	
-	if (me==NULL || object_data_is_libdata(ob)) {
+	if (me == NULL || object_data_is_libdata(ob)) {
 		ob->mode &= ~OB_MODE_VERTEX_PAINT;
 		return OPERATOR_PASS_THROUGH;
 	}
 	
-	if (me && me->mloopcol==NULL) make_vertexcol(ob);
+	if (me && me->mloopcol == NULL) {
+		make_vertexcol(ob);
+	}
 	
 	/* toggle: end vpaint */
 	if (ob->mode & OB_MODE_VERTEX_PAINT) {
@@ -2562,8 +2564,8 @@ static int set_vpaint(bContext *C, wmOperator *op)		/* toggle */
 		if (ob->mode & OB_MODE_WEIGHT_PAINT)
 			set_wpaint(C, op);
 		
-		if (vp==NULL)
-			vp= scene->toolsettings->vpaint= new_vpaint(0);
+		if (vp == NULL)
+			vp = scene->toolsettings->vpaint = new_vpaint(0);
 		
 		paint_cursor_start(C, vertex_paint_poll);
 
@@ -2632,7 +2634,7 @@ typedef struct VPaintData {
 	 * otherwise we need to refresh the modifier stack */
 	int use_fast_update;
 
-	/*mpoly -> mface mapping*/
+	/* mpoly -> mface mapping */
 	MemArena *polyfacemap_arena;
 	ListBase *polyfacemap;
 } VPaintData;
@@ -2644,10 +2646,10 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
 	int *origIndex;
 	int i;
 
-	vd->polyfacemap_arena = BLI_memarena_new(1<<13, "vpaint tmp");
+	vd->polyfacemap_arena = BLI_memarena_new(1 << 13, "vpaint tmp");
 	BLI_memarena_use_calloc(vd->polyfacemap_arena);
 
-	vd->polyfacemap = BLI_memarena_alloc(vd->polyfacemap_arena, sizeof(ListBase)*me->totpoly);
+	vd->polyfacemap = BLI_memarena_alloc(vd->polyfacemap_arena, sizeof(ListBase) * me->totpoly);
 
 	origIndex = CustomData_get_layer(&me->fdata, CD_POLYINDEX);
 	mf = me->mface;
@@ -2655,7 +2657,7 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
 	if (!origIndex)
 		return;
 
-	for (i=0; i<me->totface; i++, mf++, origIndex++) {
+	for (i = 0; i < me->totface; i++, mf++, origIndex++) {
 		if (*origIndex == ORIGINDEX_NONE)
 			continue;
 
@@ -2668,32 +2670,32 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
 
 static int vpaint_stroke_test_start(bContext *C, struct wmOperator *op, wmEvent *UNUSED(event))
 {
-	ToolSettings *ts= CTX_data_tool_settings(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
 	struct PaintStroke *stroke = op->customdata;
-	VPaint *vp= ts->vpaint;
+	VPaint *vp = ts->vpaint;
 	struct VPaintData *vpd;
-	Object *ob= CTX_data_active_object(C);
+	Object *ob = CTX_data_active_object(C);
 	Mesh *me;
 	float mat[4][4], imat[4][4];
 
 	/* context checks could be a poll() */
-	me= get_mesh(ob);
-	if (me==NULL || me->totpoly==0)
+	me = get_mesh(ob);
+	if (me == NULL || me->totpoly == 0)
 		return OPERATOR_PASS_THROUGH;
 	
-	if (me->mloopcol==NULL)
+	if (me->mloopcol == NULL)
 		make_vertexcol(ob);
-	if (me->mloopcol==NULL)
+	if (me->mloopcol == NULL)
 		return OPERATOR_CANCELLED;
 	
 	/* make mode data storage */
-	vpd= MEM_callocN(sizeof(struct VPaintData), "VPaintData");
+	vpd = MEM_callocN(sizeof(struct VPaintData), "VPaintData");
 	paint_stroke_set_mode_data(stroke, vpd);
 	view3d_set_viewcontext(C, &vpd->vc);
 	
-	vpd->vertexcosnos= mesh_get_mapped_verts_nors(vpd->vc.scene, ob);
-	vpd->indexar= get_indexarray(me);
-	vpd->paintcol= vpaint_get_current_col(vp);
+	vpd->vertexcosnos = mesh_get_mapped_verts_nors(vpd->vc.scene, ob);
+	vpd->indexar = get_indexarray(me);
+	vpd->paintcol = vpaint_get_current_col(vp);
 
 
 	/* are we painting onto a modified mesh?,
@@ -2726,36 +2728,36 @@ static void vpaint_paint_face(VPaint *vp, VPaintData *vpd, Object *ob,
 	ViewContext *vc = &vpd->vc;
 	Brush *brush = paint_brush(&vp->paint);
 	Mesh *me = get_mesh(ob);
-	MFace *mface= &me->mface[index];
-	unsigned int *mcol= ((unsigned int*)me->mcol) + 4*index;
-	unsigned int *mcolorig= ((unsigned int*)vp->vpaint_prev) + 4*index;
+	MFace *mface = &me->mface[index];
+	unsigned int *mcol = ((unsigned int *)me->mcol) + 4 * index;
+	unsigned int *mcolorig = ((unsigned int *)vp->vpaint_prev) + 4 * index;
 	float alpha;
 	int i;
 
 	int brush_alpha_pressure_i;
 	
-	if ((vp->flag & VP_COLINDEX && mface->mat_nr!=ob->actcol-1) ||
+	if ((vp->flag & VP_COLINDEX && mface->mat_nr != ob->actcol - 1) ||
 	   ((me->editflag & ME_EDIT_PAINT_MASK) && !(mface->flag & ME_FACE_SEL)))
 		return;
 
 	if (brush->vertexpaint_tool == PAINT_BLEND_BLUR) {
-		unsigned int fcol1= mcol_blend( mcol[0], mcol[1], 128);
+		unsigned int fcol1 = mcol_blend( mcol[0], mcol[1], 128);
 		if (mface->v4) {
-			unsigned int fcol2= mcol_blend( mcol[2], mcol[3], 128);
-			vpd->paintcol= mcol_blend( fcol1, fcol2, 128);
+			unsigned int fcol2 = mcol_blend( mcol[2], mcol[3], 128);
+			vpd->paintcol = mcol_blend( fcol1, fcol2, 128);
 		}
 		else {
-			vpd->paintcol= mcol_blend( mcol[2], fcol1, 170);
+			vpd->paintcol = mcol_blend( mcol[2], fcol1, 170);
 		}
 	}
 
-	brush_alpha_pressure_i = (int)(brush_alpha_pressure*255.0f);
+	brush_alpha_pressure_i = (int)(brush_alpha_pressure * 255.0f);
 
 	for (i = 0; i < (mface->v4 ? 4 : 3); ++i) {
-		alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat, vpd->vertexcosnos+6*(&mface->v1)[i],
+		alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat, vpd->vertexcosnos + 6 * (&mface->v1)[i],
 		                         mval, brush_size_pressure, brush_alpha_pressure);
 		if (alpha) {
-			const int alpha_i = (int)(alpha*255.0f);
+			const int alpha_i = (int)(alpha * 255.0f);
 			mcol[i] = vpaint_blend(vp, mcol[i], mcolorig[i], vpd->paintcol, alpha_i, brush_alpha_pressure_i);
 		}
 	}
@@ -2773,25 +2775,25 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
 	ViewContext *vc = &vpd->vc;
 	Brush *brush = paint_brush(&vp->paint);
 	Mesh *me = get_mesh(ob);
-	MPoly *mpoly= &me->mpoly[index];
+	MPoly *mpoly = &me->mpoly[index];
 	MFace *mf;
 	MCol *mc;
 	MLoop *ml;
 	MLoopCol *mlc;
 	polyfacemap_e *e;
-	unsigned int *lcol = ((unsigned int*)me->mloopcol) + mpoly->loopstart;
-	unsigned int *lcolorig = ((unsigned int*)vp->vpaint_prev) + mpoly->loopstart;
+	unsigned int *lcol = ((unsigned int *)me->mloopcol) + mpoly->loopstart;
+	unsigned int *lcolorig = ((unsigned int *)vp->vpaint_prev) + mpoly->loopstart;
 	float alpha;
 	int i, j;
 
-	int brush_alpha_pressure_i = (int)(brush_alpha_pressure*255.0f);
+	int brush_alpha_pressure_i = (int)(brush_alpha_pressure * 255.0f);
 
 	if (brush->vertexpaint_tool == PAINT_BLEND_BLUR) {
 		unsigned int blend[4] = {0};
 		unsigned int tcol;
 		char *col;
 
-		for (j=0; j<mpoly->totloop; j++) {
+		for (j = 0; j < mpoly->totloop; j++) {
 			col = (char *)(lcol + j);
 			blend[0] += col[0];
 			blend[1] += col[1];
@@ -2813,12 +2815,12 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
 	}
 
 	ml = me->mloop + mpoly->loopstart;
-	for (i=0; i<mpoly->totloop; i++, ml++) {
-		alpha= calc_vp_alpha_dl(vp, vc, vpd->vpimat,
-								vpd->vertexcosnos+6*ml->v, mval,
-								brush_size_pressure, brush_alpha_pressure);
+	for (i = 0; i < mpoly->totloop; i++, ml++) {
+		alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat,
+		                         vpd->vertexcosnos + 6 * ml->v, mval,
+		                         brush_size_pressure, brush_alpha_pressure);
 		if (alpha > 0.0f) {
-			const int alpha_i = (int)(alpha*255.0f);
+			const int alpha_i = (int)(alpha * 255.0f);
 			lcol[i] = vpaint_blend(vp, lcol[i], lcolorig[i], vpd->paintcol, alpha_i, brush_alpha_pressure_i);
 		}
 	}
@@ -2834,19 +2836,19 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
 		 * rather then regenerating the tessellation altogether */
 		for (e = vpd->polyfacemap[index].first; e; e = e->next) {
 			mf = me->mface + e->facenr;
-			mc = me->mcol + e->facenr*4;
+			mc = me->mcol + e->facenr * 4;
 
 			ml = me->mloop + mpoly->loopstart;
 			mlc = me->mloopcol + mpoly->loopstart;
-			for (j=0; j<mpoly->totloop; j++, ml++, mlc++) {
+			for (j = 0; j < mpoly->totloop; j++, ml++, mlc++) {
 				if (ml->v == mf->v1)
 					CPYCOL(mc, mlc);
 				else if (ml->v == mf->v2)
-					CPYCOL(mc+1, mlc);
+					CPYCOL(mc + 1, mlc);
 				else if (ml->v == mf->v3)
-					CPYCOL(mc+2, mlc);
+					CPYCOL(mc + 2, mlc);
 				else if (mf->v4 && ml->v == mf->v4)
-					CPYCOL(mc+3, mlc);
+					CPYCOL(mc + 3, mlc);
 
 			}
 		}
@@ -2857,16 +2859,16 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
 
 static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
 {
-	Scene *scene= CTX_data_scene(C);
-	ToolSettings *ts= CTX_data_tool_settings(C);
+	Scene *scene = CTX_data_scene(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
 	struct VPaintData *vpd = paint_stroke_mode_data(stroke);
-	VPaint *vp= ts->vpaint;
+	VPaint *vp = ts->vpaint;
 	Brush *brush = paint_brush(&vp->paint);
-	ViewContext *vc= &vpd->vc;
-	Object *ob= vc->obact;
-	Mesh *me= ob->data;
+	ViewContext *vc = &vpd->vc;
+	Object *ob = vc->obact;
+	Mesh *me = ob->data;
 	float mat[4][4];
-	int *indexar= vpd->indexar;
+	int *indexar = vpd->indexar;
 	int totindex, index, flip;
 	float mval[2];
 
@@ -2884,40 +2886,40 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	/* load projection matrix */
 	mult_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
 
-	mval[0]-= vc->ar->winrct.xmin;
-	mval[1]-= vc->ar->winrct.ymin;
+	mval[0] -= vc->ar->winrct.xmin;
+	mval[1] -= vc->ar->winrct.ymin;
 
 			
 	/* which faces are involved */
 	if (vp->flag & VP_AREA) {
-		totindex= sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
+		totindex = sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
 	}
 	else {
-		indexar[0]= view3d_sample_backbuf(vc, mval[0], mval[1]);
-		if (indexar[0]) totindex= 1;
-		else totindex= 0;
+		indexar[0] = view3d_sample_backbuf(vc, mval[0], mval[1]);
+		if (indexar[0]) totindex = 1;
+		else totindex = 0;
 	}
 			
 			
 	if (vp->flag & VP_COLINDEX) {
-		for (index=0; index<totindex; index++) {
-			if (indexar[index] && indexar[index]<=me->totpoly) {
-				MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
+		for (index = 0; index < totindex; index++) {
+			if (indexar[index] && indexar[index] <= me->totpoly) {
+				MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
 						
-				if (mpoly->mat_nr!=ob->actcol-1) {
-					indexar[index]= 0;
+				if (mpoly->mat_nr != ob->actcol - 1) {
+					indexar[index] = 0;
 				}
 			}
 		}
 	}
 
 	if ((me->editflag & ME_EDIT_PAINT_MASK) && me->mpoly) {
-		for (index=0; index<totindex; index++) {
-			if (indexar[index] && indexar[index]<=me->totpoly) {
-				MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
+		for (index = 0; index < totindex; index++) {
+			if (indexar[index] && indexar[index] <= me->totpoly) {
+				MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
 						
-				if ((mpoly->flag & ME_FACE_SEL)==0)
-					indexar[index]= 0;
+				if ((mpoly->flag & ME_FACE_SEL) == 0)
+					indexar[index] = 0;
 			}					
 		}
 	}
@@ -2925,10 +2927,10 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	swap_m4m4(vc->rv3d->persmat, mat);
 
 			
-	for (index=0; index<totindex; index++) {
+	for (index = 0; index < totindex; index++) {
 				
-		if (indexar[index] && indexar[index]<=me->totpoly) {
-			vpaint_paint_poly(vp, vpd, ob, indexar[index]-1, mval, brush_size_pressure, brush_alpha_pressure, flip);
+		if (indexar[index] && indexar[index] <= me->totpoly) {
+			vpaint_paint_poly(vp, vpd, ob, indexar[index] - 1, mval, brush_size_pressure, brush_alpha_pressure, flip);
 		}
 	}
 		
@@ -2951,8 +2953,8 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 
 static void vpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
 {
-	ToolSettings *ts= CTX_data_tool_settings(C);
-	struct VPaintData *vpd= paint_stroke_mode_data(stroke);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	struct VPaintData *vpd = paint_stroke_mode_data(stroke);
 	
 	if (vpd->vertexcosnos)
 		MEM_freeN(vpd->vertexcosnos);
@@ -3013,18 +3015,18 @@ void PAINT_OT_vertex_paint(wmOperatorType *ot)
 
 static int weight_from_bones_poll(bContext *C)
 {
-	Object *ob= CTX_data_active_object(C);
+	Object *ob = CTX_data_active_object(C);
 
 	return (ob && (ob->mode & OB_MODE_WEIGHT_PAINT) && modifiers_isDeformedByArmature(ob));
 }
 
 static int weight_from_bones_exec(bContext *C, wmOperator *op)
 {
-	Scene *scene= CTX_data_scene(C);
-	Object *ob= CTX_data_active_object(C);
-	Object *armob= modifiers_isDeformedByArmature(ob);
-	Mesh *me= ob->data;
-	int type= RNA_enum_get(op->ptr, "type");
+	Scene *scene = CTX_data_scene(C);
+	Object *ob = CTX_data_active_object(C);
+	Object *armob = modifiers_isDeformedByArmature(ob);
+	Mesh *me = ob->data;
+	int type = RNA_enum_get(op->ptr, "type");
 
 	create_vgroups_from_armature(op->reports, scene, ob, armob, type, (me->editflag & ME_EDIT_MIRROR_X));
 
@@ -3036,7 +3038,7 @@ static int weight_from_bones_exec(bContext *C, wmOperator *op)
 
 void PAINT_OT_weight_from_bones(wmOperatorType *ot)
 {
-	static EnumPropertyItem type_items[]= {
+	static EnumPropertyItem type_items[] = {
 		{ARM_GROUPS_AUTO, "AUTOMATIC", 0, "Automatic", "Automatic weights froms bones"},
 		{ARM_GROUPS_ENVELOPE, "ENVELOPES", 0, "From Envelopes", "Weights from envelopes with user defined radius"},
 		{0, NULL, 0, NULL, NULL}};