style cleanup: modifiers

1 files changed, 235 insertions, 231 deletions

diff --git a/source/blender/modifiers/intern/MOD_screw.c b/source/blender/modifiers/intern/MOD_screw.c
index 60eed4abcb1..e6cff1c042f 100644
--- a/source/blender/modifiers/intern/MOD_screw.c
+++ b/source/blender/modifiers/intern/MOD_screw.c
@@ -59,8 +59,8 @@ typedef struct ScrewVertConnect {
 } ScrewVertConnect;
 
 typedef struct ScrewVertIter {
-	ScrewVertConnect * v_array;
-	ScrewVertConnect * v_poin;
+	ScrewVertConnect *v_array;
+	ScrewVertConnect *v_poin;
 	int v;
 	int v_other;
 	MEdge *e;
@@ -78,8 +78,8 @@ static void screwvert_iter_init(ScrewVertIter *iter, ScrewVertConnect *array, in
 		iter->e = iter->v_poin->e[!dir];
 	}
 	else {
-		iter->v_poin= NULL;
-		iter->e= NULL;
+		iter->v_poin = NULL;
+		iter->e = NULL;
 	}
 }	
 
@@ -87,82 +87,82 @@ static void screwvert_iter_init(ScrewVertIter *iter, ScrewVertConnect *array, in
 static void screwvert_iter_step(ScrewVertIter *iter)
 {
 	if (iter->v_poin->v[0] == iter->v_other) {
-		iter->v_other= iter->v;
-		iter->v= iter->v_poin->v[1];
+		iter->v_other = iter->v;
+		iter->v = iter->v_poin->v[1];
 	}
 	else if (iter->v_poin->v[1] == iter->v_other) {
-		iter->v_other= iter->v;
-		iter->v= iter->v_poin->v[0];
+		iter->v_other = iter->v;
+		iter->v = iter->v_poin->v[0];
 	}
-	if (iter->v >= 0)	{
-		iter->v_poin= &iter->v_array[iter->v];
-		iter->e= iter->v_poin->e[(iter->v_poin->e[0] == iter->e)];
+	if (iter->v >= 0)   {
+		iter->v_poin = &iter->v_array[iter->v];
+		iter->e = iter->v_poin->e[(iter->v_poin->e[0] == iter->e)];
 	}
 	else {
-		iter->e= NULL;
-		iter->v_poin= NULL;
+		iter->e = NULL;
+		iter->v_poin = NULL;
 	}
 }
 
 
 static void initData(ModifierData *md)
 {
-	ScrewModifierData *ltmd= (ScrewModifierData*) md;
-	ltmd->ob_axis= NULL;
-	ltmd->angle= M_PI * 2.0;
-	ltmd->axis= 2;
-	ltmd->flag= 0;
-	ltmd->steps= 16;
-	ltmd->render_steps= 16;
-	ltmd->iter= 1;
+	ScrewModifierData *ltmd = (ScrewModifierData *) md;
+	ltmd->ob_axis = NULL;
+	ltmd->angle = M_PI * 2.0;
+	ltmd->axis = 2;
+	ltmd->flag = 0;
+	ltmd->steps = 16;
+	ltmd->render_steps = 16;
+	ltmd->iter = 1;
 }
 
 static void copyData(ModifierData *md, ModifierData *target)
 {
-	ScrewModifierData *sltmd= (ScrewModifierData*) md;
-	ScrewModifierData *tltmd= (ScrewModifierData*) target;
+	ScrewModifierData *sltmd = (ScrewModifierData *) md;
+	ScrewModifierData *tltmd = (ScrewModifierData *) target;
 	
-	tltmd->ob_axis= sltmd->ob_axis;
-	tltmd->angle= sltmd->angle;
-	tltmd->axis= sltmd->axis;
-	tltmd->flag= sltmd->flag;
-	tltmd->steps= sltmd->steps;
-	tltmd->render_steps= sltmd->render_steps;
-	tltmd->screw_ofs= sltmd->screw_ofs;
-	tltmd->iter= sltmd->iter;
+	tltmd->ob_axis = sltmd->ob_axis;
+	tltmd->angle = sltmd->angle;
+	tltmd->axis = sltmd->axis;
+	tltmd->flag = sltmd->flag;
+	tltmd->steps = sltmd->steps;
+	tltmd->render_steps = sltmd->render_steps;
+	tltmd->screw_ofs = sltmd->screw_ofs;
+	tltmd->iter = sltmd->iter;
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
-						DerivedMesh *derivedData,
-						int useRenderParams,
-						int UNUSED(isFinalCalc))
+                                  DerivedMesh *derivedData,
+                                  int useRenderParams,
+                                  int UNUSED(isFinalCalc))
 {
-	DerivedMesh *dm= derivedData;
+	DerivedMesh *dm = derivedData;
 	DerivedMesh *result;
-	ScrewModifierData *ltmd= (ScrewModifierData*) md;
+	ScrewModifierData *ltmd = (ScrewModifierData *) md;
 	
 	int *origindex;
-	int mpoly_index=0;
+	int mpoly_index = 0;
 	int step;
 	int i, j;
 	unsigned int i1, i2;
-	int step_tot= useRenderParams ? ltmd->render_steps : ltmd->steps;
+	int step_tot = useRenderParams ? ltmd->render_steps : ltmd->steps;
 	const int do_flip = ltmd->flag & MOD_SCREW_NORMAL_FLIP ? 1 : 0;
-	int maxVerts=0, maxEdges=0, maxPolys=0;
-	const unsigned int totvert= dm->getNumVerts(dm);
-	const unsigned int totedge= dm->getNumEdges(dm);
-
-	char axis_char= 'X', close;
-	float angle= ltmd->angle;
-	float screw_ofs= ltmd->screw_ofs;
-	float axis_vec[3]= {0.0f, 0.0f, 0.0f};
+	int maxVerts = 0, maxEdges = 0, maxPolys = 0;
+	const unsigned int totvert = dm->getNumVerts(dm);
+	const unsigned int totedge = dm->getNumEdges(dm);
+
+	char axis_char = 'X', close;
+	float angle = ltmd->angle;
+	float screw_ofs = ltmd->screw_ofs;
+	float axis_vec[3] = {0.0f, 0.0f, 0.0f};
 	float tmp_vec1[3], tmp_vec2[3]; 
 	float mat3[3][3];
 	float mtx_tx[4][4]; /* transform the coords by an object relative to this objects transformation */
 	float mtx_tx_inv[4][4]; /* inverted */
 	float mtx_tmp_a[4][4];
 	
-	int vc_tot_linked= 0;
+	int vc_tot_linked = 0;
 	short other_axis_1, other_axis_2;
 	float *tmpf1, *tmpf2;
 
@@ -173,28 +173,28 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	MEdge *medge_orig, *med_orig, *med_new, *med_new_firstloop, *medge_new;
 	MVert *mvert_new, *mvert_orig, *mv_orig, *mv_new, *mv_new_base;
 
-	ScrewVertConnect *vc, *vc_tmp, *vert_connect= NULL;
+	ScrewVertConnect *vc, *vc_tmp, *vert_connect = NULL;
 
 	/* don't do anything? */
 	if (!totvert)
 		return CDDM_from_template(dm, 0, 0, 0, 0, 0);
 
 	switch (ltmd->axis) {
-	case 0:
-		other_axis_1=1;
-		other_axis_2=2;
-		break;
-	case 1:
-		other_axis_1=0;
-		other_axis_2=2;
-		break;
-	default: /* 2, use default to quiet warnings */
-		other_axis_1=0;
-		other_axis_2=1;
-		break;
+		case 0:
+			other_axis_1 = 1;
+			other_axis_2 = 2;
+			break;
+		case 1:
+			other_axis_1 = 0;
+			other_axis_2 = 2;
+			break;
+		default: /* 2, use default to quiet warnings */
+			other_axis_1 = 0;
+			other_axis_2 = 1;
+			break;
 	}
 
-	axis_vec[ltmd->axis]= 1.0f;
+	axis_vec[ltmd->axis] = 1.0f;
 
 	if (ltmd->ob_axis) {
 		/* calc the matrix relative to the axis object */
@@ -212,23 +212,23 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 			float totlen = len_v3(mtx_tx[3]);
 
 			if (totlen != 0.0f) {
-				float zero[3]={0.0f, 0.0f, 0.0f};
+				float zero[3] = {0.0f, 0.0f, 0.0f};
 				float cp[3];				
-				screw_ofs= closest_to_line_v3(cp, mtx_tx[3], zero, axis_vec);
+				screw_ofs = closest_to_line_v3(cp, mtx_tx[3], zero, axis_vec);
 			}
 			else {
-				screw_ofs= 0.0f;
+				screw_ofs = 0.0f;
 			}
 		}
 
 		/* angle */
 
-#if 0	// cant incluide this, not predictable enough, though quite fun,.
+#if 0   // cant incluide this, not predictable enough, though quite fun,.
 		if (ltmd->flag & MOD_SCREW_OBJECT_ANGLE) {
 			float mtx3_tx[3][3];
 			copy_m3_m4(mtx3_tx, mtx_tx);
 
-			float vec[3] = {0,1,0};
+			float vec[3] = {0, 1, 0};
 			float cross1[3];
 			float cross2[3];
 			cross_v3_v3v3(cross1, vec, axis_vec);
@@ -243,13 +243,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 				cross_v3_v3v3(c2, axis_vec, c1);
 
 
-				angle= angle_v3v3(cross1, c2);
+				angle = angle_v3v3(cross1, c2);
 
 				cross_v3_v3v3(axis_tmp, cross1, c2);
 				normalize_v3(axis_tmp);
 
 				if (len_v3v3(axis_tmp, axis_vec) > 1.0f)
-					angle= -angle;
+					angle = -angle;
 
 			}
 		}
@@ -261,7 +261,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 		/* useful to be able to use the axis vec in some cases still */
 		zero_v3(axis_vec);
-		axis_vec[ltmd->axis]= 1.0f;
+		axis_vec[ltmd->axis] = 1.0f;
 	}
 
 	/* apply the multiplier */
@@ -273,38 +273,40 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 	/* will the screw be closed?
 	 * Note! smaller then FLT_EPSILON*100 gives problems with float precision so its never closed. */
-	if (fabsf(screw_ofs) <= (FLT_EPSILON*100.0f) && fabsf(fabsf(angle) - ((float)M_PI * 2.0f)) <= (FLT_EPSILON*100.0f)) {
-		close= 1;
+	if (fabsf(screw_ofs) <= (FLT_EPSILON * 100.0f) &&
+	    fabsf(fabsf(angle) - ((float)M_PI * 2.0f)) <= (FLT_EPSILON * 100.0f))
+	{
+		close = 1;
 		step_tot--;
-		if (step_tot < 3) step_tot= 3;
+		if (step_tot < 3) step_tot = 3;
 	
-		maxVerts =	totvert  * step_tot; /* -1 because we're joining back up */
-		maxEdges =	(totvert * step_tot) + /* these are the edges between new verts */
-					(totedge * step_tot); /* -1 because vert edges join */
-		maxPolys =	totedge * step_tot;
+		maxVerts =  totvert  * step_tot;   /* -1 because we're joining back up */
+		maxEdges =  (totvert * step_tot) + /* these are the edges between new verts */
+		            (totedge * step_tot);  /* -1 because vert edges join */
+		maxPolys =  totedge * step_tot;
 
-		screw_ofs= 0.0f;
+		screw_ofs = 0.0f;
 	}
 	else {
-		close= 0;
-		if (step_tot < 3) step_tot= 3;
+		close = 0;
+		if (step_tot < 3) step_tot = 3;
 
-		maxVerts =	totvert  * step_tot; /* -1 because we're joining back up */
-		maxEdges =	(totvert * (step_tot-1)) + /* these are the edges between new verts */
-					(totedge * step_tot); /* -1 because vert edges join */
-		maxPolys =	totedge * (step_tot-1);
+		maxVerts =  totvert  * step_tot; /* -1 because we're joining back up */
+		maxEdges =  (totvert * (step_tot - 1)) + /* these are the edges between new verts */
+		           (totedge * step_tot);  /* -1 because vert edges join */
+		maxPolys =  totedge * (step_tot - 1);
 	}
 	
-	result= CDDM_from_template(dm, maxVerts, maxEdges, 0, maxPolys * 4, maxPolys);
+	result = CDDM_from_template(dm, maxVerts, maxEdges, 0, maxPolys * 4, maxPolys);
 	
 	/* copy verts from mesh */
-	mvert_orig =	dm->getVertArray(dm);
-	medge_orig =	dm->getEdgeArray(dm);
+	mvert_orig =    dm->getVertArray(dm);
+	medge_orig =    dm->getEdgeArray(dm);
 	
-	mvert_new =		result->getVertArray(result);
-	mpoly_new =		result->getPolyArray(result);
-	mloop_new =		result->getLoopArray(result);
-	medge_new =		result->getEdgeArray(result);
+	mvert_new =     result->getVertArray(result);
+	mpoly_new =     result->getPolyArray(result);
+	mloop_new =     result->getLoopArray(result);
+	medge_new =     result->getEdgeArray(result);
 
 	if (!CustomData_has_layer(&result->polyData, CD_ORIGINDEX)) {
 		CustomData_add_layer(&result->polyData, CD_ORIGINDEX, CD_CALLOC, NULL, maxPolys);
@@ -320,17 +322,17 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	
 	/* Set the locations of the first set of verts */
 	
-	mv_new= mvert_new;
-	mv_orig= mvert_orig;
+	mv_new = mvert_new;
+	mv_orig = mvert_orig;
 	
 	/* Copy the first set of edges */
-	med_orig= medge_orig;
-	med_new= medge_new;
-	for (i=0; i < totedge; i++, med_orig++, med_new++) {
-		med_new->v1= med_orig->v1;
-		med_new->v2= med_orig->v2;
-		med_new->crease= med_orig->crease;
-		med_new->flag= med_orig->flag &  ~ME_LOOSEEDGE;
+	med_orig = medge_orig;
+	med_new = medge_new;
+	for (i = 0; i < totedge; i++, med_orig++, med_new++) {
+		med_new->v1 = med_orig->v1;
+		med_new->v2 = med_orig->v2;
+		med_new->crease = med_orig->crease;
+		med_new->flag = med_orig->flag &  ~ME_LOOSEEDGE;
 	}
 	
 	if (ltmd->flag & MOD_SCREW_NORMAL_CALC) {
@@ -358,14 +360,14 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		 * This makes the modifier faster with one less alloc.
 		 */
 
-		vert_connect= MEM_mallocN(sizeof(ScrewVertConnect) * totvert, "ScrewVertConnect");
+		vert_connect = MEM_mallocN(sizeof(ScrewVertConnect) * totvert, "ScrewVertConnect");
 		//vert_connect= (ScrewVertConnect *) &medge_new[totvert]; /* skip the first slice of verts */
-		vc= vert_connect;
+		vc = vert_connect;
 
 		/* Copy Vert Locations */
 		/* - We can do this in a later loop - only do here if no normal calc */
 		if (!totedge) {
-			for (i=0; i < totvert; i++, mv_orig++, mv_new++) {
+			for (i = 0; i < totvert; i++, mv_orig++, mv_new++) {
 				copy_v3_v3(mv_new->co, mv_orig->co);
 				normalize_v3_v3(vc->no, mv_new->co); /* no edges- this is really a dummy normal */
 			}
@@ -373,93 +375,95 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		else {
 			/*printf("\n\n\n\n\nStarting Modifier\n");*/
 			/* set edge users */
-			med_new= medge_new;
-			mv_new= mvert_new;
+			med_new = medge_new;
+			mv_new = mvert_new;
 
 			if (ltmd->ob_axis) {
 				/*mtx_tx is initialized early on */
-				for (i=0; i < totvert; i++, mv_new++, mv_orig++, vc++) {
-					vc->co[0]= mv_new->co[0]= mv_orig->co[0];
-					vc->co[1]= mv_new->co[1]= mv_orig->co[1];
-					vc->co[2]= mv_new->co[2]= mv_orig->co[2];
+				for (i = 0; i < totvert; i++, mv_new++, mv_orig++, vc++) {
+					vc->co[0] = mv_new->co[0] = mv_orig->co[0];
+					vc->co[1] = mv_new->co[1] = mv_orig->co[1];
+					vc->co[2] = mv_new->co[2] = mv_orig->co[2];
 
-					vc->flag= 0;
-					vc->e[0]= vc->e[1]= NULL;
-					vc->v[0]= vc->v[1]= -1;
+					vc->flag = 0;
+					vc->e[0] = vc->e[1] = NULL;
+					vc->v[0] = vc->v[1] = -1;
 
 					mul_m4_v3(mtx_tx, vc->co);
 					/* length in 2d, don't sqrt because this is only for comparison */
-					vc->dist =	vc->co[other_axis_1]*vc->co[other_axis_1] +
-								vc->co[other_axis_2]*vc->co[other_axis_2];
+					vc->dist =  vc->co[other_axis_1] * vc->co[other_axis_1] +
+					           vc->co[other_axis_2] * vc->co[other_axis_2];
 
 					/* printf("location %f %f %f -- %f\n", vc->co[0], vc->co[1], vc->co[2], vc->dist);*/
 				}
 			}
 			else {
-				for (i=0; i < totvert; i++, mv_new++, mv_orig++, vc++) {
-					vc->co[0]= mv_new->co[0]= mv_orig->co[0];
-					vc->co[1]= mv_new->co[1]= mv_orig->co[1];
-					vc->co[2]= mv_new->co[2]= mv_orig->co[2];
+				for (i = 0; i < totvert; i++, mv_new++, mv_orig++, vc++) {
+					vc->co[0] = mv_new->co[0] = mv_orig->co[0];
+					vc->co[1] = mv_new->co[1] = mv_orig->co[1];
+					vc->co[2] = mv_new->co[2] = mv_orig->co[2];
 
-					vc->flag= 0;
-					vc->e[0]= vc->e[1]= NULL;
-					vc->v[0]= vc->v[1]= -1;
+					vc->flag = 0;
+					vc->e[0] = vc->e[1] = NULL;
+					vc->v[0] = vc->v[1] = -1;
 
 					/* length in 2d, don't sqrt because this is only for comparison */
-					vc->dist =	vc->co[other_axis_1]*vc->co[other_axis_1] +
-								vc->co[other_axis_2]*vc->co[other_axis_2];
+					vc->dist =  vc->co[other_axis_1] * vc->co[other_axis_1] +
+					           vc->co[other_axis_2] * vc->co[other_axis_2];
 
 					/* printf("location %f %f %f -- %f\n", vc->co[0], vc->co[1], vc->co[2], vc->dist);*/
 				}
 			}
 
 			/* this loop builds connectivity info for verts */
-			for (i=0; i<totedge; i++, med_new++) {
-				vc= &vert_connect[med_new->v1];
+			for (i = 0; i < totedge; i++, med_new++) {
+				vc = &vert_connect[med_new->v1];
 
 				if (vc->v[0] == -1) { /* unused */
-					vc->v[0]= med_new->v2;
-					vc->e[0]= med_new;
+					vc->v[0] = med_new->v2;
+					vc->e[0] = med_new;
 				}
 				else if (vc->v[1] == -1) {
-					vc->v[1]= med_new->v2;
-					vc->e[1]= med_new;
+					vc->v[1] = med_new->v2;
+					vc->e[1] = med_new;
 				}
 				else {
-					vc->v[0]= vc->v[1]= -2; /* erro value  - don't use, 3 edges on vert */
+					vc->v[0] = vc->v[1] = -2; /* erro value  - don't use, 3 edges on vert */
 				}
 
-				vc= &vert_connect[med_new->v2];
+				vc = &vert_connect[med_new->v2];
 
 				/* same as above but swap v1/2 */
 				if (vc->v[0] == -1) { /* unused */
-					vc->v[0]= med_new->v1;
-					vc->e[0]= med_new;
+					vc->v[0] = med_new->v1;
+					vc->e[0] = med_new;
 				}
 				else if (vc->v[1] == -1) {
-					vc->v[1]= med_new->v1;
-					vc->e[1]= med_new;
+					vc->v[1] = med_new->v1;
+					vc->e[1] = med_new;
 				}
 				else {
-					vc->v[0]= vc->v[1]= -2; /* erro value  - don't use, 3 edges on vert */
+					vc->v[0] = vc->v[1] = -2; /* erro value  - don't use, 3 edges on vert */
 				}
 			}
 
 			/* find the first vert */
-			vc= vert_connect;
-			for (i=0; i < totvert; i++, vc++) {
+			vc = vert_connect;
+			for (i = 0; i < totvert; i++, vc++) {
 				/* Now do search for connected verts, order all edges and flip them
 				 * so resulting faces are flipped the right way */
-				vc_tot_linked= 0; /* count the number of linked verts for this loop */
+				vc_tot_linked = 0; /* count the number of linked verts for this loop */
 				if (vc->flag == 0) {
-					int v_best=-1, ed_loop_closed=0; /* vert and vert new */
+					int v_best = -1, ed_loop_closed = 0; /* vert and vert new */
 					ScrewVertIter lt_iter;
-					int ed_loop_flip= 0; /* compiler complains if not initialized, but it should be initialized below */
-					float fl= -1.0f;
+					float fl = -1.0f;
+
+					/* compiler complains if not initialized, but it should be initialized below */
+					int ed_loop_flip = 0;
 
 					/*printf("Loop on connected vert: %i\n", i);*/
 
-					for (j=0; j<2; j++) {
+					for (j = 0; j < 2; j++) {
 						/*printf("\tSide: %i\n", j);*/
 						screwvert_iter_init(&lt_iter, vert_connect, i, j);
 						if (j == 1) {
@@ -470,15 +474,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 							if (lt_iter.v_poin->flag) {
 								/*printf("\t\t\tBreaking Found end\n");*/
 								//endpoints[0]= endpoints[1]= -1;
-								ed_loop_closed= 1; /* circle */
+								ed_loop_closed = 1; /* circle */
 								break;
 							}
-							lt_iter.v_poin->flag= 1;
+							lt_iter.v_poin->flag = 1;
 							vc_tot_linked++;
 							/*printf("Testing 2 floats %f : %f\n", fl, lt_iter.v_poin->dist);*/
 							if (fl <= lt_iter.v_poin->dist) {
-								fl= lt_iter.v_poin->dist;
-								v_best= lt_iter.v;
+								fl = lt_iter.v_poin->dist;
+								v_best = lt_iter.v;
 								/*printf("\t\t\tVERT BEST: %i\n", v_best);*/
 							}
 							screwvert_iter_step(&lt_iter);
@@ -495,13 +499,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 					/*printf("Done Looking - vc_tot_linked: %i\n", vc_tot_linked);*/
 
-					if (vc_tot_linked>1) {
+					if (vc_tot_linked > 1) {
 						float vf_1, vf_2, vf_best;
 
-						vc_tmp= &vert_connect[v_best];
+						vc_tmp = &vert_connect[v_best];
 
-						tmpf1= vert_connect[vc_tmp->v[0]].co;
-						tmpf2= vert_connect[vc_tmp->v[1]].co;
+						tmpf1 = vert_connect[vc_tmp->v[0]].co;
+						tmpf2 = vert_connect[vc_tmp->v[1]].co;
 
 
 						/* edge connects on each side! */
@@ -509,15 +513,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 							/*printf("Verts on each side (%i %i)\n", vc_tmp->v[0], vc_tmp->v[1]);*/
 							/* find out which is higher */
 
-							vf_1= tmpf1[ltmd->axis];
-							vf_2= tmpf2[ltmd->axis];
-							vf_best= vc_tmp->co[ltmd->axis];
+							vf_1 = tmpf1[ltmd->axis];
+							vf_2 = tmpf2[ltmd->axis];
+							vf_best = vc_tmp->co[ltmd->axis];
 
 							if (vf_1 < vf_best && vf_best < vf_2) {
-								ed_loop_flip= 0;
+								ed_loop_flip = 0;
 							}
 							else if (vf_1 > vf_best && vf_best > vf_2) {
-								ed_loop_flip= 1;
+								ed_loop_flip = 1;
 							}
 							else {
 								/* not so simple to work out which edge is higher */
@@ -527,20 +531,20 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 								normalize_v3(tmp_vec2);
 
 								if (tmp_vec1[ltmd->axis] < tmp_vec2[ltmd->axis]) {
-									ed_loop_flip= 1;
+									ed_loop_flip = 1;
 								}
 								else {
-									ed_loop_flip= 0;
+									ed_loop_flip = 0;
 								}
 							}
 						}
 						else if (vc_tmp->v[0] >= 0) { /*vertex only connected on 1 side */
 							/*printf("Verts on ONE side (%i %i)\n", vc_tmp->v[0], vc_tmp->v[1]);*/
 							if (tmpf1[ltmd->axis] < vc_tmp->co[ltmd->axis]) { /* best is above */
-								ed_loop_flip= 1;
+								ed_loop_flip = 1;
 							}
 							else { /* best is below or even... in even case we cant know whet  to do. */
-								ed_loop_flip= 0;
+								ed_loop_flip = 0;
 							}
 
 						}
@@ -557,31 +561,31 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 						 * note: flip is now done at face level so copying vgroup slizes is easier */
 #if 0
 						if (do_flip)
-							ed_loop_flip= !ed_loop_flip;
+							ed_loop_flip = !ed_loop_flip;
 #endif
 
 						if (angle < 0.0f)
-							ed_loop_flip= !ed_loop_flip;
+							ed_loop_flip = !ed_loop_flip;
 
 						/* if its closed, we only need 1 loop */
-						for (j=ed_loop_closed; j<2; j++) {
+						for (j = ed_loop_closed; j < 2; j++) {
 							/*printf("Ordering Side J %i\n", j);*/
 
 							screwvert_iter_init(&lt_iter, vert_connect, v_best, j);
 							/*printf("\n\nStarting - Loop\n");*/
-							lt_iter.v_poin->flag= 1; /* so a non loop will traverse the other side */
+							lt_iter.v_poin->flag = 1; /* so a non loop will traverse the other side */
 
 
 							/* If this is the vert off the best vert and
 							 * the best vert has 2 edges connected too it
 							 * then swap the flip direction */
 							if (j == 1 && (vc_tmp->v[0] > -1) && (vc_tmp->v[1] > -1))
-								ed_loop_flip= !ed_loop_flip;
+								ed_loop_flip = !ed_loop_flip;
 
 							while (lt_iter.v_poin && lt_iter.v_poin->flag != 2) {
 								/*printf("\tOrdering Vert V %i\n", lt_iter.v);*/
 
-								lt_iter.v_poin->flag= 2;
+								lt_iter.v_poin->flag = 2;
 								if (lt_iter.e) {
 									if (lt_iter.v == lt_iter.e->v1) {
 										if (ed_loop_flip == 0) {
@@ -589,8 +593,8 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 											SWAP(unsigned int, lt_iter.e->v1, lt_iter.e->v2);
 										}
 										/* else {
-											printf("\t\t\tFlipping Not 0\n");
-										}*/
+										    printf("\t\t\tFlipping Not 0\n");
+										   }*/
 									}
 									else if (lt_iter.v == lt_iter.e->v2) {
 										if (ed_loop_flip == 1) {
@@ -598,16 +602,16 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 											SWAP(unsigned int, lt_iter.e->v1, lt_iter.e->v2);
 										}
 										/* else {
-											printf("\t\t\tFlipping Not 1\n");
-										}*/
+										    printf("\t\t\tFlipping Not 1\n");
+										   }*/
 									}
 									/* else {
-										printf("\t\tIncorrect edge topology");
-									}*/
+									    printf("\t\tIncorrect edge topology");
+									   }*/
 								}
 								/* else {
-									printf("\t\tNo Edge at this point\n");
-								}*/
+								    printf("\t\tNo Edge at this point\n");
+								   }*/
 								screwvert_iter_step(&lt_iter);
 							}
 						}
@@ -676,23 +680,23 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		}
 	}
 	else {
-		mv_orig= mvert_orig;
-		mv_new= mvert_new;
+		mv_orig = mvert_orig;
+		mv_new = mvert_new;
 
-		for (i=0; i < totvert; i++, mv_new++, mv_orig++) {
+		for (i = 0; i < totvert; i++, mv_new++, mv_orig++) {
 			copy_v3_v3(mv_new->co, mv_orig->co);
 		}
 	}
 	/* done with edge connectivity based normal flipping */
 	
 	/* Add Faces */
-	for (step=1; step < step_tot; step++) {
-		const int varray_stride= totvert * step;
+	for (step = 1; step < step_tot; step++) {
+		const int varray_stride = totvert * step;
 		float step_angle;
 		float nor_tx[3];
 		float mat[4][4];
 		/* Rotation Matrix */
-		step_angle= (angle / (step_tot - (!close))) * step;
+		step_angle = (angle / (step_tot - (!close))) * step;
 
 		if (ltmd->ob_axis) {
 			axis_angle_to_mat3(mat3, axis_vec, step_angle);
@@ -705,15 +709,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		}
 
 		if (screw_ofs)
-			madd_v3_v3fl(mat[3], axis_vec, screw_ofs * ((float)step / (float)(step_tot-1)));
+			madd_v3_v3fl(mat[3], axis_vec, screw_ofs * ((float)step / (float)(step_tot - 1)));
 
 		/* copy a slice */
 		DM_copy_vert_data(dm, result, 0, varray_stride, totvert);
 		
-		mv_new_base= mvert_new;
-		mv_new= &mvert_new[varray_stride]; /* advance to the next slice */
+		mv_new_base = mvert_new;
+		mv_new = &mvert_new[varray_stride]; /* advance to the next slice */
 		
-		for (j=0; j<totvert; j++, mv_new_base++, mv_new++) {
+		for (j = 0; j < totvert; j++, mv_new_base++, mv_new++) {
 			/* set normal */
 			if (vert_connect) {
 				mul_v3_m3v3(nor_tx, mat3, vert_connect[j].no);
@@ -740,9 +744,9 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 			}
 			
 			/* add the new edge */
-			med_new->v1= varray_stride + j;
-			med_new->v2= med_new->v1 - totvert;
-			med_new->flag= ME_EDGEDRAW|ME_EDGERENDER;
+			med_new->v1 = varray_stride + j;
+			med_new->v2 = med_new->v1 - totvert;
+			med_new->flag = ME_EDGEDRAW | ME_EDGERENDER;
 			med_new++;
 		}
 	}
@@ -750,34 +754,34 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	/* we can avoid if using vert alloc trick */
 	if (vert_connect) {
 		MEM_freeN(vert_connect);
-		vert_connect= NULL;
+		vert_connect = NULL;
 	}
 
 	if (close) {
 		/* last loop of edges, previous loop dosnt account for the last set of edges */
-		const int varray_stride= (step_tot - 1) * totvert;
+		const int varray_stride = (step_tot - 1) * totvert;
 
-		for (i=0; i<totvert; i++) {
-			med_new->v1= i;
-			med_new->v2= varray_stride + i;
-			med_new->flag= ME_EDGEDRAW|ME_EDGERENDER;
+		for (i = 0; i < totvert; i++) {
+			med_new->v1 = i;
+			med_new->v2 = varray_stride + i;
+			med_new->flag = ME_EDGEDRAW | ME_EDGERENDER;
 			med_new++;
 		}
 	}
 	
-	mp_new= mpoly_new;
-	ml_new= mloop_new;
-	med_new_firstloop= medge_new;
+	mp_new = mpoly_new;
+	ml_new = mloop_new;
+	med_new_firstloop = medge_new;
 	
 	/* more of an offset in this case */
 	edge_offset = totedge + (totvert * (step_tot - (close ? 0 : 1)));
 
-	for (i=0; i < totedge; i++, med_new_firstloop++) {
+	for (i = 0; i < totedge; i++, med_new_firstloop++) {
 		/* for each edge, make a cylinder of quads */
-		i1= med_new_firstloop->v1;
-		i2= med_new_firstloop->v2;
+		i1 = med_new_firstloop->v1;
+		i2 = med_new_firstloop->v2;
 
-		for (step=0; step < step_tot-1; step++) {
+		for (step = 0; step < step_tot - 1; step++) {
 			
 			/* new face */
 			if (do_flip) {
@@ -806,18 +810,18 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 			mp_new->loopstart = mpoly_index * 4;
 			mp_new->totloop = 4;
-			mp_new->flag= ME_SMOOTH;
-			origindex[mpoly_index]= ORIGINDEX_NONE;
+			mp_new->flag = ME_SMOOTH;
+			origindex[mpoly_index] = ORIGINDEX_NONE;
 			mp_new++;
 			ml_new += 4;
 			mpoly_index++;
 			
 			/* new vertical edge */
 			if (step) { /* The first set is already dome */
-				med_new->v1= i1;
-				med_new->v2= i2;
-				med_new->flag= med_new_firstloop->flag;
-				med_new->crease= med_new_firstloop->crease;
+				med_new->v1 = i1;
+				med_new->v2 = i2;
+				med_new->flag = med_new_firstloop->flag;
+				med_new->crease = med_new_firstloop->crease;
 				med_new++;
 			}
 			i1 += totvert;
@@ -851,18 +855,18 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 			mp_new->loopstart = mpoly_index * 4;
 			mp_new->totloop = 4;
-			mp_new->flag= ME_SMOOTH;
-			origindex[mpoly_index]= ORIGINDEX_NONE;
+			mp_new->flag = ME_SMOOTH;
+			origindex[mpoly_index] = ORIGINDEX_NONE;
 			mp_new++;
 			ml_new += 4;
 			mpoly_index++;
 		}
 		
 		/* new vertical edge */
-		med_new->v1= i1;
-		med_new->v2= i2;
-		med_new->flag= med_new_firstloop->flag & ~ME_LOOSEEDGE;
-		med_new->crease= med_new_firstloop->crease;
+		med_new->v1 = i1;
+		med_new->v2 = i2;
+		med_new->flag = med_new_firstloop->flag & ~ME_LOOSEEDGE;
+		med_new->crease = med_new_firstloop->crease;
 		med_new++;
 	}
 
@@ -871,7 +875,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	{
 		i = 0;
 		printf("\n");
-		for ( ; i < maxPolys * 4; i += 4) {
+		for (; i < maxPolys * 4; i += 4) {
 			int ii;
 			ml_new = mloop_new + i;
 			ii = findEd(medge_new, maxEdges, ml_new[0].v, ml_new[1].v);
@@ -904,37 +908,37 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
-						struct Scene *UNUSED(scene),
-						Object *UNUSED(ob),
-						DagNode *obNode)
+                           struct Scene *UNUSED(scene),
+                           Object *UNUSED(ob),
+                           DagNode *obNode)
 {
-	ScrewModifierData *ltmd= (ScrewModifierData*) md;
+	ScrewModifierData *ltmd = (ScrewModifierData *) md;
 
 	if (ltmd->ob_axis) {
-		DagNode *curNode= dag_get_node(forest, ltmd->ob_axis);
+		DagNode *curNode = dag_get_node(forest, ltmd->ob_axis);
 
 		dag_add_relation(forest, curNode, obNode,
-						 DAG_RL_DATA_DATA | DAG_RL_OB_DATA,
-						 "Screw Modifier");
+		                 DAG_RL_DATA_DATA | DAG_RL_OB_DATA,
+		                 "Screw Modifier");
 	}
 }
 
 static void foreachObjectLink(
-				ModifierData *md, Object *ob,
-				void (*walk)(void *userData, Object *ob, Object **obpoin),
-				void *userData)
+        ModifierData *md, Object *ob,
+        void (*walk)(void *userData, Object *ob, Object **obpoin),
+        void *userData)
 {
-	ScrewModifierData *ltmd= (ScrewModifierData*) md;
+	ScrewModifierData *ltmd = (ScrewModifierData *) md;
 
 	walk(userData, ob, &ltmd->ob_axis);
 }
 
 /* This dosnt work with material*/
 static DerivedMesh *applyModifierEM(
-						ModifierData *md,
-						Object *ob,
-						struct BMEditMesh *UNUSED(editData),
-						DerivedMesh *derivedData)
+        ModifierData *md,
+        Object *ob,
+        struct BMEditMesh *UNUSED(editData),
+        DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
 }
@@ -951,10 +955,10 @@ ModifierTypeInfo modifierType_Screw = {
 	/* structSize */        sizeof(ScrewModifierData),
 	/* type */              eModifierTypeType_Constructive,
 
-	/* flags */             eModifierTypeFlag_AcceptsMesh
-							| eModifierTypeFlag_AcceptsCVs
-							| eModifierTypeFlag_SupportsEditmode
-							| eModifierTypeFlag_EnableInEditmode,
+	/* flags */             eModifierTypeFlag_AcceptsMesh |
+	                        eModifierTypeFlag_AcceptsCVs |
+	                        eModifierTypeFlag_SupportsEditmode |
+	                        eModifierTypeFlag_EnableInEditmode,
 
 	/* copyData */          copyData,
 	/* deformVerts */       NULL,