converted more mixed tab/space indentations to tabs. only whitespace changes.

4 files changed, 521 insertions, 521 deletions

diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 3a34b048aa3..90954fef1c7 100644
--- a/source/blender/modifiers/intern/MOD_array.c
+++ b/source/blender/modifiers/intern/MOD_array.c
@@ -313,60 +313,60 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 		else
 			/* if the offset has no translation, just make one copy */
 			count = 1;
-		  }
+	}
 
-		  if(count < 1)
-			  count = 1;
+	if(count < 1)
+		count = 1;
 
 	/* allocate memory for count duplicates (including original) plus
 		  * start and end caps
 	*/
-		  finalVerts = dm->getNumVerts(dm) * count;
-		  finalEdges = dm->getNumEdges(dm) * count;
-		  finalFaces = dm->getNumFaces(dm) * count;
-		  if(start_cap) {
-			  finalVerts += start_cap->getNumVerts(start_cap);
-			  finalEdges += start_cap->getNumEdges(start_cap);
-			  finalFaces += start_cap->getNumFaces(start_cap);
-		  }
-		  if(end_cap) {
-			  finalVerts += end_cap->getNumVerts(end_cap);
-			  finalEdges += end_cap->getNumEdges(end_cap);
-			  finalFaces += end_cap->getNumFaces(end_cap);
-		  }
-		  result = CDDM_from_template(dm, finalVerts, finalEdges, finalFaces);
-
-		  /* calculate the offset matrix of the final copy (for merging) */ 
-		  unit_m4(final_offset);
-
-		  for(j=0; j < count - 1; j++) {
-			  mul_m4_m4m4(tmp_mat, final_offset, offset);
-			  copy_m4_m4(final_offset, tmp_mat);
-		  }
-
-		  numVerts = numEdges = numFaces = 0;
-		  mvert = CDDM_get_verts(result);
-
-		  for (i = 0; i < maxVerts; i++) {
-			  indexMap[i].merge = -1; /* default to no merge */
-			  indexMap[i].merge_final = 0; /* default to no merge */
-		  }
-
-		  for (i = 0; i < maxVerts; i++) {
-			  MVert *inMV;
-			  MVert *mv = &mvert[numVerts];
-			  MVert *mv2;
-			  float co[3];
-
-			  inMV = &src_mvert[i];
-
-			  DM_copy_vert_data(dm, result, i, numVerts, 1);
-			  *mv = *inMV;
-			  numVerts++;
-
-			  indexMap[i].new = numVerts - 1;
-
-			  copy_v3_v3(co, mv->co);
+	finalVerts = dm->getNumVerts(dm) * count;
+	finalEdges = dm->getNumEdges(dm) * count;
+	finalFaces = dm->getNumFaces(dm) * count;
+	if(start_cap) {
+		finalVerts += start_cap->getNumVerts(start_cap);
+		finalEdges += start_cap->getNumEdges(start_cap);
+		finalFaces += start_cap->getNumFaces(start_cap);
+	}
+	if(end_cap) {
+		finalVerts += end_cap->getNumVerts(end_cap);
+		finalEdges += end_cap->getNumEdges(end_cap);
+		finalFaces += end_cap->getNumFaces(end_cap);
+	}
+	result = CDDM_from_template(dm, finalVerts, finalEdges, finalFaces);
+
+	/* calculate the offset matrix of the final copy (for merging) */
+	unit_m4(final_offset);
+
+	for(j=0; j < count - 1; j++) {
+		mul_m4_m4m4(tmp_mat, final_offset, offset);
+		copy_m4_m4(final_offset, tmp_mat);
+	}
+
+	numVerts = numEdges = numFaces = 0;
+	mvert = CDDM_get_verts(result);
+
+	for (i = 0; i < maxVerts; i++) {
+		indexMap[i].merge = -1; /* default to no merge */
+		indexMap[i].merge_final = 0; /* default to no merge */
+	}
+
+	for (i = 0; i < maxVerts; i++) {
+		MVert *inMV;
+		MVert *mv = &mvert[numVerts];
+		MVert *mv2;
+		float co[3];
+
+		inMV = &src_mvert[i];
+
+		DM_copy_vert_data(dm, result, i, numVerts, 1);
+		*mv = *inMV;
+		numVerts++;
+
+		indexMap[i].new = numVerts - 1;
+
+		copy_v3_v3(co, mv->co);
 		
 		/* Attempts to merge verts from one duplicate with verts from the
 			  * next duplicate which are closer than amd->merge_dist.
@@ -374,405 +374,405 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 			  * If verts are merged in the first duplicate pair, they are merged
 			  * in all pairs.
 		*/
-			  if((count > 1) && (amd->flags & MOD_ARR_MERGE)) {
-				  float tmp_co[3];
-				  mul_v3_m4v3(tmp_co, offset, mv->co);
-
-				  for(j = 0; j < maxVerts; j++) {
-					  /* if vertex already merged, don't use it */
-					  if( indexMap[j].merge != -1 ) continue;
-
-					  inMV = &src_mvert[j];
-					  /* if this vert is within merge limit, merge */
-					  if(compare_len_v3v3(tmp_co, inMV->co, amd->merge_dist)) {
-						  indexMap[i].merge = j;
-
-						  /* test for merging with final copy of merge target */
-						  if(amd->flags & MOD_ARR_MERGEFINAL) {
-							  copy_v3_v3(tmp_co, inMV->co);
-							  inMV = &src_mvert[i];
-							  mul_m4_v3(final_offset, tmp_co);
-							  if(compare_len_v3v3(tmp_co, inMV->co, amd->merge_dist))
-								  indexMap[i].merge_final = 1;
-						  }
-						  break;
-					  }
-				  }
-			  }
-
-			  /* if no merging, generate copies of this vert */
-			  if(indexMap[i].merge < 0) {
-				  for(j=0; j < count - 1; j++) {
-					  mv2 = &mvert[numVerts];
-
-					  DM_copy_vert_data(result, result, numVerts - 1, numVerts, 1);
-					  *mv2 = *mv;
-					  numVerts++;
-
-					  mul_m4_v3(offset, co);
-					  copy_v3_v3(mv2->co, co);
-				  }
-			  } else if(indexMap[i].merge != i && indexMap[i].merge_final) {
+		if((count > 1) && (amd->flags & MOD_ARR_MERGE)) {
+			float tmp_co[3];
+			mul_v3_m4v3(tmp_co, offset, mv->co);
+
+			for(j = 0; j < maxVerts; j++) {
+				/* if vertex already merged, don't use it */
+				if( indexMap[j].merge != -1 ) continue;
+
+				inMV = &src_mvert[j];
+				/* if this vert is within merge limit, merge */
+				if(compare_len_v3v3(tmp_co, inMV->co, amd->merge_dist)) {
+					indexMap[i].merge = j;
+
+					/* test for merging with final copy of merge target */
+					if(amd->flags & MOD_ARR_MERGEFINAL) {
+						copy_v3_v3(tmp_co, inMV->co);
+						inMV = &src_mvert[i];
+						mul_m4_v3(final_offset, tmp_co);
+						if(compare_len_v3v3(tmp_co, inMV->co, amd->merge_dist))
+							indexMap[i].merge_final = 1;
+					}
+					break;
+				}
+			}
+		}
+
+		/* if no merging, generate copies of this vert */
+		if(indexMap[i].merge < 0) {
+			for(j=0; j < count - 1; j++) {
+				mv2 = &mvert[numVerts];
+
+				DM_copy_vert_data(result, result, numVerts - 1, numVerts, 1);
+				*mv2 = *mv;
+				numVerts++;
+
+				mul_m4_v3(offset, co);
+				copy_v3_v3(mv2->co, co);
+			}
+		} else if(indexMap[i].merge != i && indexMap[i].merge_final) {
 			/* if this vert is not merging with itself, and it is merging
 				  * with the final copy of its merge target, remove the first copy
 			*/
-				  numVerts--;
-				  DM_free_vert_data(result, numVerts, 1);
-			  }
-		  }
+			numVerts--;
+			DM_free_vert_data(result, numVerts, 1);
+		}
+	}
 
-		  /* make a hashtable so we can avoid duplicate edges from merging */
-		  edges = BLI_edgehash_new();
+	/* make a hashtable so we can avoid duplicate edges from merging */
+	edges = BLI_edgehash_new();
 
-		  maxEdges = dm->getNumEdges(dm);
-		  medge = CDDM_get_edges(result);
-		  for(i = 0; i < maxEdges; i++) {
-			  MEdge inMED;
-			  MEdge med;
-			  MEdge *med2;
-			  int vert1, vert2;
+	maxEdges = dm->getNumEdges(dm);
+	medge = CDDM_get_edges(result);
+	for(i = 0; i < maxEdges; i++) {
+		MEdge inMED;
+		MEdge med;
+		MEdge *med2;
+		int vert1, vert2;
 
-			  dm->getEdge(dm, i, &inMED);
+		dm->getEdge(dm, i, &inMED);
 
-			  med = inMED;
-			  med.v1 = indexMap[inMED.v1].new;
-			  med.v2 = indexMap[inMED.v2].new;
+		med = inMED;
+		med.v1 = indexMap[inMED.v1].new;
+		med.v2 = indexMap[inMED.v2].new;
 
 		/* if vertices are to be merged with the final copies of their
 			  * merge targets, calculate that final copy
 		*/
-			  if(indexMap[inMED.v1].merge_final) {
-				  med.v1 = calc_mapping(indexMap, indexMap[inMED.v1].merge,
-						  count - 1);
-			  }
-			  if(indexMap[inMED.v2].merge_final) {
-				  med.v2 = calc_mapping(indexMap, indexMap[inMED.v2].merge,
-						  count - 1);
-			  }
-
-			  if(med.v1 == med.v2) continue;
-			  
-			  /* XXX Unfortunately the calc_mapping returns sometimes numVerts... leads to bad crashes */
-			  if(med.v1 >= numVerts)
-				  med.v1= numVerts-1;
-			  if(med.v2 >= numVerts)
-				  med.v2= numVerts-1;
-			  
-			  if (initFlags) {
-				  med.flag |= ME_EDGEDRAW | ME_EDGERENDER;
-			  }
-
-			  if(!BLI_edgehash_haskey(edges, med.v1, med.v2)) {
-				  DM_copy_edge_data(dm, result, i, numEdges, 1);
-				  medge[numEdges] = med;
-				  numEdges++;
-
-				  BLI_edgehash_insert(edges, med.v1, med.v2, NULL);
-			  }
-
-			  for(j = 1; j < count; j++)
-			  {
-				  vert1 = calc_mapping(indexMap, inMED.v1, j);
-				  vert2 = calc_mapping(indexMap, inMED.v2, j);
-				  
-				  /* edge could collapse to single point after mapping */
-				  if(vert1 == vert2) continue;
-				  
-				  /* XXX Unfortunately the calc_mapping returns sometimes numVerts... leads to bad crashes */
-				  if(vert1 >= numVerts)
-					  vert1= numVerts-1;
-				  if(vert2 >= numVerts)
-					  vert2= numVerts-1;
-
-				  /* avoid duplicate edges */
-				  if(!BLI_edgehash_haskey(edges, vert1, vert2)) {
-					  med2 = &medge[numEdges];
-
-					  DM_copy_edge_data(dm, result, i, numEdges, 1);
-					  *med2 = med;
-					  numEdges++;
-
-					  med2->v1 = vert1;
-					  med2->v2 = vert2;
-
-					  BLI_edgehash_insert(edges, med2->v1, med2->v2, NULL);
-				  }
-			  }
-		  }
-
-		  maxFaces = dm->getNumFaces(dm);
-		  mface = CDDM_get_faces(result);
-		  for (i=0; i < maxFaces; i++) {
-			  MFace inMF;
-			  MFace *mf = &mface[numFaces];
-
-			  dm->getFace(dm, i, &inMF);
-
-			  DM_copy_face_data(dm, result, i, numFaces, 1);
-			  *mf = inMF;
-
-			  mf->v1 = indexMap[inMF.v1].new;
-			  mf->v2 = indexMap[inMF.v2].new;
-			  mf->v3 = indexMap[inMF.v3].new;
-			  if(inMF.v4)
-				  mf->v4 = indexMap[inMF.v4].new;
+		if(indexMap[inMED.v1].merge_final) {
+			med.v1 = calc_mapping(indexMap, indexMap[inMED.v1].merge,
+			count - 1);
+		}
+		if(indexMap[inMED.v2].merge_final) {
+			med.v2 = calc_mapping(indexMap, indexMap[inMED.v2].merge,
+			count - 1);
+		}
+
+		if(med.v1 == med.v2) continue;
+
+		/* XXX Unfortunately the calc_mapping returns sometimes numVerts... leads to bad crashes */
+		if(med.v1 >= numVerts)
+			med.v1= numVerts-1;
+		if(med.v2 >= numVerts)
+			med.v2= numVerts-1;
+
+		if (initFlags) {
+			med.flag |= ME_EDGEDRAW | ME_EDGERENDER;
+		}
+
+		if(!BLI_edgehash_haskey(edges, med.v1, med.v2)) {
+			DM_copy_edge_data(dm, result, i, numEdges, 1);
+			medge[numEdges] = med;
+			numEdges++;
+
+			BLI_edgehash_insert(edges, med.v1, med.v2, NULL);
+		}
+
+		for(j = 1; j < count; j++)
+		{
+			vert1 = calc_mapping(indexMap, inMED.v1, j);
+			vert2 = calc_mapping(indexMap, inMED.v2, j);
+
+			/* edge could collapse to single point after mapping */
+			if(vert1 == vert2) continue;
+
+			/* XXX Unfortunately the calc_mapping returns sometimes numVerts... leads to bad crashes */
+			if(vert1 >= numVerts)
+				vert1= numVerts-1;
+			if(vert2 >= numVerts)
+				vert2= numVerts-1;
+
+			/* avoid duplicate edges */
+			if(!BLI_edgehash_haskey(edges, vert1, vert2)) {
+				med2 = &medge[numEdges];
+
+				DM_copy_edge_data(dm, result, i, numEdges, 1);
+				*med2 = med;
+				numEdges++;
+
+				med2->v1 = vert1;
+				med2->v2 = vert2;
+
+				BLI_edgehash_insert(edges, med2->v1, med2->v2, NULL);
+			}
+		}
+	}
+
+	maxFaces = dm->getNumFaces(dm);
+	mface = CDDM_get_faces(result);
+	for (i=0; i < maxFaces; i++) {
+		MFace inMF;
+		MFace *mf = &mface[numFaces];
+
+		dm->getFace(dm, i, &inMF);
+
+		DM_copy_face_data(dm, result, i, numFaces, 1);
+		*mf = inMF;
+
+		mf->v1 = indexMap[inMF.v1].new;
+		mf->v2 = indexMap[inMF.v2].new;
+		mf->v3 = indexMap[inMF.v3].new;
+		if(inMF.v4)
+			mf->v4 = indexMap[inMF.v4].new;
 
 		/* if vertices are to be merged with the final copies of their
 			  * merge targets, calculate that final copy
 		*/
-			  if(indexMap[inMF.v1].merge_final)
-				  mf->v1 = calc_mapping(indexMap, indexMap[inMF.v1].merge, count-1);
-			  if(indexMap[inMF.v2].merge_final)
-				  mf->v2 = calc_mapping(indexMap, indexMap[inMF.v2].merge, count-1);
-			  if(indexMap[inMF.v3].merge_final)
-				  mf->v3 = calc_mapping(indexMap, indexMap[inMF.v3].merge, count-1);
-			  if(inMF.v4 && indexMap[inMF.v4].merge_final)
-				  mf->v4 = calc_mapping(indexMap, indexMap[inMF.v4].merge, count-1);
-
-			  if(test_index_face_maxvert(mf, &result->faceData, numFaces, inMF.v4?4:3, numVerts) < 3)
-				  continue;
-
-			  numFaces++;
-
-			  /* if the face has fewer than 3 vertices, don't create it */
-			  if(mf->v3 == 0 || (mf->v1 && (mf->v1 == mf->v3 || mf->v1 == mf->v4))) {
-				  numFaces--;
-				  DM_free_face_data(result, numFaces, 1);
-			  }
-
-			  for(j = 1; j < count; j++)
-			  {
-				  MFace *mf2 = &mface[numFaces];
-
-				  DM_copy_face_data(dm, result, i, numFaces, 1);
-				  *mf2 = *mf;
-
-				  mf2->v1 = calc_mapping(indexMap, inMF.v1, j);
-				  mf2->v2 = calc_mapping(indexMap, inMF.v2, j);
-				  mf2->v3 = calc_mapping(indexMap, inMF.v3, j);
-				  if (inMF.v4)
-					  mf2->v4 = calc_mapping(indexMap, inMF.v4, j);
-
-				  numFaces++;
-
-				  /* if the face has fewer than 3 vertices, don't create it */
-				  if(test_index_face_maxvert(mf2, &result->faceData, numFaces-1, inMF.v4?4:3, numVerts) < 3) {
-					  numFaces--;
-					  DM_free_face_data(result, numFaces, 1);
-								 }
-			  }
-		  }
-
-		  /* add start and end caps */
-		  if(start_cap) {
-			  float startoffset[4][4];
-			  MVert *cap_mvert;
-			  MEdge *cap_medge;
-			  MFace *cap_mface;
-			  int *origindex;
-			  int *vert_map;
-			  int capVerts, capEdges, capFaces;
-
-			  capVerts = start_cap->getNumVerts(start_cap);
-			  capEdges = start_cap->getNumEdges(start_cap);
-			  capFaces = start_cap->getNumFaces(start_cap);
-			  cap_mvert = start_cap->getVertArray(start_cap);
-			  cap_medge = start_cap->getEdgeArray(start_cap);
-			  cap_mface = start_cap->getFaceArray(start_cap);
-
-			  invert_m4_m4(startoffset, offset);
-
-			  vert_map = MEM_callocN(sizeof(*vert_map) * capVerts,
-					  "arrayModifier_doArray vert_map");
-
-			  origindex = result->getVertDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capVerts; i++) {
-				  MVert *mv = &cap_mvert[i];
-				  short merged = 0;
-
-				  if(amd->flags & MOD_ARR_MERGE) {
-					  float tmp_co[3];
-					  MVert *in_mv;
-					  int j;
-
-					  copy_v3_v3(tmp_co, mv->co);
-					  mul_m4_v3(startoffset, tmp_co);
-
-					  for(j = 0; j < maxVerts; j++) {
-						  in_mv = &src_mvert[j];
-						  /* if this vert is within merge limit, merge */
-						  if(compare_len_v3v3(tmp_co, in_mv->co, amd->merge_dist)) {
-							  vert_map[i] = calc_mapping(indexMap, j, 0);
-							  merged = 1;
-							  break;
-						  }
-					  }
-				  }
-
-				  if(!merged) {
-					  DM_copy_vert_data(start_cap, result, i, numVerts, 1);
-					  mvert[numVerts] = *mv;
-					  mul_m4_v3(startoffset, mvert[numVerts].co);
-					  origindex[numVerts] = ORIGINDEX_NONE;
-
-					  vert_map[i] = numVerts;
-
-					  numVerts++;
-				  }
-			  }
-			  origindex = result->getEdgeDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capEdges; i++) {
-				  int v1, v2;
-
-				  v1 = vert_map[cap_medge[i].v1];
-				  v2 = vert_map[cap_medge[i].v2];
-
-				  if(!BLI_edgehash_haskey(edges, v1, v2)) {
-					  DM_copy_edge_data(start_cap, result, i, numEdges, 1);
-					  medge[numEdges] = cap_medge[i];
-					  medge[numEdges].v1 = v1;
-					  medge[numEdges].v2 = v2;
-					  origindex[numEdges] = ORIGINDEX_NONE;
-
-					  numEdges++;
-				  }
-			  }
-			  origindex = result->getFaceDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capFaces; i++) {
-				  DM_copy_face_data(start_cap, result, i, numFaces, 1);
-				  mface[numFaces] = cap_mface[i];
-				  mface[numFaces].v1 = vert_map[mface[numFaces].v1];
-				  mface[numFaces].v2 = vert_map[mface[numFaces].v2];
-				  mface[numFaces].v3 = vert_map[mface[numFaces].v3];
-				  if(mface[numFaces].v4) {
-					  mface[numFaces].v4 = vert_map[mface[numFaces].v4];
-
-					  test_index_face_maxvert(&mface[numFaces], &result->faceData,
-									  numFaces, 4, numVerts);
-				  }
-				  else
-				  {
-					  test_index_face(&mface[numFaces], &result->faceData,
-									  numFaces, 3);
-				  }
-
-				  origindex[numFaces] = ORIGINDEX_NONE;
-
-				  numFaces++;
-			  }
-
-			  MEM_freeN(vert_map);
-			  start_cap->release(start_cap);
-		  }
-
-		  if(end_cap) {
-			  float endoffset[4][4];
-			  MVert *cap_mvert;
-			  MEdge *cap_medge;
-			  MFace *cap_mface;
-			  int *origindex;
-			  int *vert_map;
-			  int capVerts, capEdges, capFaces;
-
-			  capVerts = end_cap->getNumVerts(end_cap);
-			  capEdges = end_cap->getNumEdges(end_cap);
-			  capFaces = end_cap->getNumFaces(end_cap);
-			  cap_mvert = end_cap->getVertArray(end_cap);
-			  cap_medge = end_cap->getEdgeArray(end_cap);
-			  cap_mface = end_cap->getFaceArray(end_cap);
-
-			  mul_m4_m4m4(endoffset, final_offset, offset);
-
-			  vert_map = MEM_callocN(sizeof(*vert_map) * capVerts,
-					  "arrayModifier_doArray vert_map");
-
-			  origindex = result->getVertDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capVerts; i++) {
-				  MVert *mv = &cap_mvert[i];
-				  short merged = 0;
-
-				  if(amd->flags & MOD_ARR_MERGE) {
-					  float tmp_co[3];
-					  MVert *in_mv;
-					  int j;
-
-					  copy_v3_v3(tmp_co, mv->co);
-					  mul_m4_v3(offset, tmp_co);
-
-					  for(j = 0; j < maxVerts; j++) {
-						  in_mv = &src_mvert[j];
-						  /* if this vert is within merge limit, merge */
-						  if(compare_len_v3v3(tmp_co, in_mv->co, amd->merge_dist)) {
-							  vert_map[i] = calc_mapping(indexMap, j, count - 1);
-							  merged = 1;
-							  break;
-						  }
-					  }
-				  }
-
-				  if(!merged) {
-					  DM_copy_vert_data(end_cap, result, i, numVerts, 1);
-					  mvert[numVerts] = *mv;
-					  mul_m4_v3(endoffset, mvert[numVerts].co);
-					  origindex[numVerts] = ORIGINDEX_NONE;
-
-					  vert_map[i] = numVerts;
-
-					  numVerts++;
-				  }
-			  }
-			  origindex = result->getEdgeDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capEdges; i++) {
-				  int v1, v2;
-
-				  v1 = vert_map[cap_medge[i].v1];
-				  v2 = vert_map[cap_medge[i].v2];
-
-				  if(!BLI_edgehash_haskey(edges, v1, v2)) {
-					  DM_copy_edge_data(end_cap, result, i, numEdges, 1);
-					  medge[numEdges] = cap_medge[i];
-					  medge[numEdges].v1 = v1;
-					  medge[numEdges].v2 = v2;
-					  origindex[numEdges] = ORIGINDEX_NONE;
-
-					  numEdges++;
-				  }
-			  }
-			  origindex = result->getFaceDataArray(result, CD_ORIGINDEX);
-			  for(i = 0; i < capFaces; i++) {
-				  DM_copy_face_data(end_cap, result, i, numFaces, 1);
-				  mface[numFaces] = cap_mface[i];
-				  mface[numFaces].v1 = vert_map[mface[numFaces].v1];
-				  mface[numFaces].v2 = vert_map[mface[numFaces].v2];
-				  mface[numFaces].v3 = vert_map[mface[numFaces].v3];
-				  if(mface[numFaces].v4) {
-					  mface[numFaces].v4 = vert_map[mface[numFaces].v4];
-
-					  test_index_face(&mface[numFaces], &result->faceData,
-									  numFaces, 4);
-				  }
-				  else
-				  {
-					  test_index_face(&mface[numFaces], &result->faceData,
-									  numFaces, 3);
-				  }
-				  origindex[numFaces] = ORIGINDEX_NONE;
-
-				  numFaces++;
-			  }
-
-			  MEM_freeN(vert_map);
-			  end_cap->release(end_cap);
-		  }
-
-		  BLI_edgehash_free(edges, NULL);
-		  MEM_freeN(indexMap);
-
-		  CDDM_lower_num_verts(result, numVerts);
-		  CDDM_lower_num_edges(result, numEdges);
-		  CDDM_lower_num_faces(result, numFaces);
-
-		  return result;
+		if(indexMap[inMF.v1].merge_final)
+			mf->v1 = calc_mapping(indexMap, indexMap[inMF.v1].merge, count-1);
+		if(indexMap[inMF.v2].merge_final)
+			mf->v2 = calc_mapping(indexMap, indexMap[inMF.v2].merge, count-1);
+		if(indexMap[inMF.v3].merge_final)
+			mf->v3 = calc_mapping(indexMap, indexMap[inMF.v3].merge, count-1);
+		if(inMF.v4 && indexMap[inMF.v4].merge_final)
+			mf->v4 = calc_mapping(indexMap, indexMap[inMF.v4].merge, count-1);
+
+		if(test_index_face_maxvert(mf, &result->faceData, numFaces, inMF.v4?4:3, numVerts) < 3)
+			continue;
+
+		numFaces++;
+
+		/* if the face has fewer than 3 vertices, don't create it */
+		if(mf->v3 == 0 || (mf->v1 && (mf->v1 == mf->v3 || mf->v1 == mf->v4))) {
+			numFaces--;
+			DM_free_face_data(result, numFaces, 1);
+		}
+
+		for(j = 1; j < count; j++)
+		{
+			MFace *mf2 = &mface[numFaces];
+
+			DM_copy_face_data(dm, result, i, numFaces, 1);
+			*mf2 = *mf;
+
+			mf2->v1 = calc_mapping(indexMap, inMF.v1, j);
+			mf2->v2 = calc_mapping(indexMap, inMF.v2, j);
+			mf2->v3 = calc_mapping(indexMap, inMF.v3, j);
+			if (inMF.v4)
+				mf2->v4 = calc_mapping(indexMap, inMF.v4, j);
+
+			numFaces++;
+
+			/* if the face has fewer than 3 vertices, don't create it */
+			if(test_index_face_maxvert(mf2, &result->faceData, numFaces-1, inMF.v4?4:3, numVerts) < 3) {
+				numFaces--;
+				DM_free_face_data(result, numFaces, 1);
+			}
+		}
+	}
+
+	/* add start and end caps */
+	if(start_cap) {
+		float startoffset[4][4];
+		MVert *cap_mvert;
+		MEdge *cap_medge;
+		MFace *cap_mface;
+		int *origindex;
+		int *vert_map;
+		int capVerts, capEdges, capFaces;
+
+		capVerts = start_cap->getNumVerts(start_cap);
+		capEdges = start_cap->getNumEdges(start_cap);
+		capFaces = start_cap->getNumFaces(start_cap);
+		cap_mvert = start_cap->getVertArray(start_cap);
+		cap_medge = start_cap->getEdgeArray(start_cap);
+		cap_mface = start_cap->getFaceArray(start_cap);
+
+		invert_m4_m4(startoffset, offset);
+
+		vert_map = MEM_callocN(sizeof(*vert_map) * capVerts,
+		"arrayModifier_doArray vert_map");
+
+		origindex = result->getVertDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capVerts; i++) {
+			MVert *mv = &cap_mvert[i];
+			short merged = 0;
+
+			if(amd->flags & MOD_ARR_MERGE) {
+				float tmp_co[3];
+				MVert *in_mv;
+				int j;
+
+				copy_v3_v3(tmp_co, mv->co);
+				mul_m4_v3(startoffset, tmp_co);
+
+				for(j = 0; j < maxVerts; j++) {
+					in_mv = &src_mvert[j];
+					/* if this vert is within merge limit, merge */
+					if(compare_len_v3v3(tmp_co, in_mv->co, amd->merge_dist)) {
+						vert_map[i] = calc_mapping(indexMap, j, 0);
+						merged = 1;
+						break;
+					}
+				}
+			}
+
+			if(!merged) {
+				DM_copy_vert_data(start_cap, result, i, numVerts, 1);
+				mvert[numVerts] = *mv;
+				mul_m4_v3(startoffset, mvert[numVerts].co);
+				origindex[numVerts] = ORIGINDEX_NONE;
+
+				vert_map[i] = numVerts;
+
+				numVerts++;
+			}
+		}
+		origindex = result->getEdgeDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capEdges; i++) {
+			int v1, v2;
+
+			v1 = vert_map[cap_medge[i].v1];
+			v2 = vert_map[cap_medge[i].v2];
+
+			if(!BLI_edgehash_haskey(edges, v1, v2)) {
+				DM_copy_edge_data(start_cap, result, i, numEdges, 1);
+				medge[numEdges] = cap_medge[i];
+				medge[numEdges].v1 = v1;
+				medge[numEdges].v2 = v2;
+				origindex[numEdges] = ORIGINDEX_NONE;
+
+				numEdges++;
+			}
+		}
+		origindex = result->getFaceDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capFaces; i++) {
+			DM_copy_face_data(start_cap, result, i, numFaces, 1);
+			mface[numFaces] = cap_mface[i];
+			mface[numFaces].v1 = vert_map[mface[numFaces].v1];
+			mface[numFaces].v2 = vert_map[mface[numFaces].v2];
+			mface[numFaces].v3 = vert_map[mface[numFaces].v3];
+			if(mface[numFaces].v4) {
+				mface[numFaces].v4 = vert_map[mface[numFaces].v4];
+
+				test_index_face_maxvert(&mface[numFaces], &result->faceData,
+				numFaces, 4, numVerts);
+			}
+			else
+			{
+				test_index_face(&mface[numFaces], &result->faceData,
+				numFaces, 3);
+			}
+
+			origindex[numFaces] = ORIGINDEX_NONE;
+
+			numFaces++;
+		}
+
+		MEM_freeN(vert_map);
+		start_cap->release(start_cap);
+	}
+
+	if(end_cap) {
+		float endoffset[4][4];
+		MVert *cap_mvert;
+		MEdge *cap_medge;
+		MFace *cap_mface;
+		int *origindex;
+		int *vert_map;
+		int capVerts, capEdges, capFaces;
+
+		capVerts = end_cap->getNumVerts(end_cap);
+		capEdges = end_cap->getNumEdges(end_cap);
+		capFaces = end_cap->getNumFaces(end_cap);
+		cap_mvert = end_cap->getVertArray(end_cap);
+		cap_medge = end_cap->getEdgeArray(end_cap);
+		cap_mface = end_cap->getFaceArray(end_cap);
+
+		mul_m4_m4m4(endoffset, final_offset, offset);
+
+		vert_map = MEM_callocN(sizeof(*vert_map) * capVerts,
+		"arrayModifier_doArray vert_map");
+
+		origindex = result->getVertDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capVerts; i++) {
+			MVert *mv = &cap_mvert[i];
+			short merged = 0;
+
+			if(amd->flags & MOD_ARR_MERGE) {
+				float tmp_co[3];
+				MVert *in_mv;
+				int j;
+
+				copy_v3_v3(tmp_co, mv->co);
+				mul_m4_v3(offset, tmp_co);
+
+				for(j = 0; j < maxVerts; j++) {
+					in_mv = &src_mvert[j];
+					/* if this vert is within merge limit, merge */
+					if(compare_len_v3v3(tmp_co, in_mv->co, amd->merge_dist)) {
+						vert_map[i] = calc_mapping(indexMap, j, count - 1);
+						merged = 1;
+						break;
+					}
+				}
+			}
+
+			if(!merged) {
+				DM_copy_vert_data(end_cap, result, i, numVerts, 1);
+				mvert[numVerts] = *mv;
+				mul_m4_v3(endoffset, mvert[numVerts].co);
+				origindex[numVerts] = ORIGINDEX_NONE;
+
+				vert_map[i] = numVerts;
+
+				numVerts++;
+			}
+		}
+		origindex = result->getEdgeDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capEdges; i++) {
+			int v1, v2;
+
+			v1 = vert_map[cap_medge[i].v1];
+			v2 = vert_map[cap_medge[i].v2];
+
+			if(!BLI_edgehash_haskey(edges, v1, v2)) {
+				DM_copy_edge_data(end_cap, result, i, numEdges, 1);
+				medge[numEdges] = cap_medge[i];
+				medge[numEdges].v1 = v1;
+				medge[numEdges].v2 = v2;
+				origindex[numEdges] = ORIGINDEX_NONE;
+
+				numEdges++;
+			}
+		}
+		origindex = result->getFaceDataArray(result, CD_ORIGINDEX);
+		for(i = 0; i < capFaces; i++) {
+			DM_copy_face_data(end_cap, result, i, numFaces, 1);
+			mface[numFaces] = cap_mface[i];
+			mface[numFaces].v1 = vert_map[mface[numFaces].v1];
+			mface[numFaces].v2 = vert_map[mface[numFaces].v2];
+			mface[numFaces].v3 = vert_map[mface[numFaces].v3];
+			if(mface[numFaces].v4) {
+				mface[numFaces].v4 = vert_map[mface[numFaces].v4];
+
+				test_index_face(&mface[numFaces], &result->faceData,
+				numFaces, 4);
+			}
+			else
+			{
+				test_index_face(&mface[numFaces], &result->faceData,
+				numFaces, 3);
+			}
+			origindex[numFaces] = ORIGINDEX_NONE;
+
+			numFaces++;
+		}
+
+		MEM_freeN(vert_map);
+		end_cap->release(end_cap);
+	}
+
+	BLI_edgehash_free(edges, NULL);
+	MEM_freeN(indexMap);
+
+	CDDM_lower_num_verts(result, numVerts);
+	CDDM_lower_num_edges(result, numEdges);
+	CDDM_lower_num_faces(result, numFaces);
+
+	return result;
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index 1cf67ac8cae..e293be5886d 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -212,17 +212,17 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 			!BLI_ghashIterator_isDone(hashIter);
 			BLI_ghashIterator_step(hashIter)
 	) {
-	   MVert source;
-	   MVert *dest;
-	   int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-	   int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+		MVert source;
+		MVert *dest;
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
+		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
 
-	   dm->getVert(dm, oldIndex, &source);
-	   dest = CDDM_get_vert(result, newIndex);
+		dm->getVert(dm, oldIndex, &source);
+		dest = CDDM_get_vert(result, newIndex);
 
-	   DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
-	   *dest = source;
-   }
+		DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
+		*dest = source;
+	}
 	BLI_ghashIterator_free(hashIter);
 	
 	/* copy the edges across, remapping indices */
diff --git a/source/blender/modifiers/intern/MOD_edgesplit.c b/source/blender/modifiers/intern/MOD_edgesplit.c
index 09e29d9ed8e..22ba1447d20 100644
--- a/source/blender/modifiers/intern/MOD_edgesplit.c
+++ b/source/blender/modifiers/intern/MOD_edgesplit.c
@@ -175,11 +175,11 @@ static SmoothMesh *smoothmesh_new(int num_verts, int num_edges, int num_faces,
 {
 	SmoothMesh *mesh = MEM_callocN(sizeof(*mesh), "smoothmesh");
 	mesh->verts = MEM_callocN(sizeof(*mesh->verts) * max_verts,
-				  "SmoothMesh.verts");
+			"SmoothMesh.verts");
 	mesh->edges = MEM_callocN(sizeof(*mesh->edges) * max_edges,
-				  "SmoothMesh.edges");
+			"SmoothMesh.edges");
 	mesh->faces = MEM_callocN(sizeof(*mesh->faces) * max_faces,
-				  "SmoothMesh.faces");
+			"SmoothMesh.faces");
 
 	mesh->num_verts = num_verts;
 	mesh->num_edges = num_edges;
@@ -280,8 +280,8 @@ static void smoothmesh_print(SmoothMesh *mesh)
 		dm->getVert(dm, vert->oldIndex, &mv);
 
 		printf("%3d: ind={%3d, %3d}, pos={% 5.1f, % 5.1f, % 5.1f}",
-			   i, vert->oldIndex, vert->newIndex,
-	 mv.co[0], mv.co[1], mv.co[2]);
+				i, vert->oldIndex, vert->newIndex,
+				mv.co[0], mv.co[1], mv.co[2]);
 		printf(", faces={");
 		for(node = vert->faces; node != NULL; node = node->next) {
 			printf(" %d", ((SmoothFace *)node->link)->newIndex);
@@ -296,8 +296,8 @@ static void smoothmesh_print(SmoothMesh *mesh)
 
 		printf("%4d: indices={%4d, %4d}, verts={%4d, %4d}",
 			   i,
-	 edge->oldIndex, edge->newIndex,
-  edge->verts[0]->newIndex, edge->verts[1]->newIndex);
+		edge->oldIndex, edge->newIndex,
+		edge->verts[0]->newIndex, edge->verts[1]->newIndex);
 		if(edge->verts[0] == edge->verts[1]) printf(" <- DUPLICATE VERTEX");
 		printf(", faces={");
 		for(node = edge->faces; node != NULL; node = node->next) {
@@ -311,7 +311,7 @@ static void smoothmesh_print(SmoothMesh *mesh)
 		SmoothFace *face = &mesh->faces[i];
 
 		printf("%4d: indices={%4d, %4d}, edges={", i,
-			   face->oldIndex, face->newIndex);
+				face->oldIndex, face->newIndex);
 		for(j = 0; j < SMOOTHFACE_MAX_EDGES && face->edges[j]; j++) {
 			if(face->flip[j])
 				printf(" -%-2d", face->edges[j]->newIndex);
@@ -339,7 +339,7 @@ static SmoothMesh *smoothmesh_from_derivedmesh(DerivedMesh *dm)
 	totface = dm->getNumFaces(dm);
 
 	mesh = smoothmesh_new(totvert, totedge, totface,
-				  totvert, totedge, totface);
+			totvert, totedge, totface);
 
 	mesh->dm = dm;
 
@@ -410,8 +410,8 @@ static DerivedMesh *CDDM_from_smoothmesh(SmoothMesh *mesh)
 {
 	DerivedMesh *result = CDDM_from_template(mesh->dm,
 			mesh->num_verts,
-   mesh->num_edges,
-   mesh->num_faces);
+			mesh->num_edges,
+			mesh->num_faces);
 	MVert *new_verts = CDDM_get_verts(result);
 	MEdge *new_edges = CDDM_get_edges(result);
 	MFace *new_faces = CDDM_get_faces(result);
@@ -422,7 +422,7 @@ static DerivedMesh *CDDM_from_smoothmesh(SmoothMesh *mesh)
 		MVert *newMV = &new_verts[vert->newIndex];
 
 		DM_copy_vert_data(mesh->dm, result,
-				  vert->oldIndex, vert->newIndex, 1);
+				vert->oldIndex, vert->newIndex, 1);
 		mesh->dm->getVert(mesh->dm, vert->oldIndex, newMV);
 	}
 
@@ -431,7 +431,7 @@ static DerivedMesh *CDDM_from_smoothmesh(SmoothMesh *mesh)
 		MEdge *newME = &new_edges[edge->newIndex];
 
 		DM_copy_edge_data(mesh->dm, result,
-				  edge->oldIndex, edge->newIndex, 1);
+				edge->oldIndex, edge->newIndex, 1);
 		mesh->dm->getEdge(mesh->dm, edge->oldIndex, newME);
 		newME->v1 = edge->verts[0]->newIndex;
 		newME->v2 = edge->verts[1]->newIndex;
@@ -442,7 +442,7 @@ static DerivedMesh *CDDM_from_smoothmesh(SmoothMesh *mesh)
 		MFace *newMF = &new_faces[face->newIndex];
 
 		DM_copy_face_data(mesh->dm, result,
-				  face->oldIndex, face->newIndex, 1);
+				face->oldIndex, face->newIndex, 1);
 		mesh->dm->getFace(mesh->dm, face->oldIndex, newMF);
 
 		newMF->v1 = face->edges[0]->verts[face->flip[0]]->newIndex;
@@ -666,7 +666,7 @@ static void edge_replace_vert(void *ptr, void *userdata)
 
 #ifdef EDGESPLIT_DEBUG_3
 	printf("replacing vert %4d with %4d in edge %4d",
-		   find->newIndex, replace->newIndex, edge->newIndex);
+			find->newIndex, replace->newIndex, edge->newIndex);
 	printf(": {%4d, %4d}", edge->verts[0]->newIndex, edge->verts[1]->newIndex);
 #endif
 
@@ -702,15 +702,15 @@ static void face_replace_edge(void *ptr, void *userdata)
 
 #ifdef EDGESPLIT_DEBUG_3
 	printf("replacing edge %4d with %4d in face %4d",
-		   find->newIndex, replace->newIndex, face->newIndex);
+			find->newIndex, replace->newIndex, face->newIndex);
 	if(face->edges[3])
 		printf(": {%2d %2d %2d %2d}",
-			   face->edges[0]->newIndex, face->edges[1]->newIndex,
-	 face->edges[2]->newIndex, face->edges[3]->newIndex);
+				face->edges[0]->newIndex, face->edges[1]->newIndex,
+				face->edges[2]->newIndex, face->edges[3]->newIndex);
 	else
 		printf(": {%2d %2d %2d}",
-			   face->edges[0]->newIndex, face->edges[1]->newIndex,
-	 face->edges[2]->newIndex);
+				face->edges[0]->newIndex, face->edges[1]->newIndex,
+				face->edges[2]->newIndex);
 #endif
 
 	for(i = 0; i < SMOOTHFACE_MAX_EDGES && face->edges[i]; i++) {
@@ -724,12 +724,12 @@ static void face_replace_edge(void *ptr, void *userdata)
 #ifdef EDGESPLIT_DEBUG_3
 	if(face->edges[3])
 		printf(" -> {%2d %2d %2d %2d}\n",
-			   face->edges[0]->newIndex, face->edges[1]->newIndex,
-	 face->edges[2]->newIndex, face->edges[3]->newIndex);
+				face->edges[0]->newIndex, face->edges[1]->newIndex,
+				face->edges[2]->newIndex, face->edges[3]->newIndex);
 	else
 		printf(" -> {%2d %2d %2d}\n",
-			   face->edges[0]->newIndex, face->edges[1]->newIndex,
-	 face->edges[2]->newIndex);
+				face->edges[0]->newIndex, face->edges[1]->newIndex,
+				face->edges[2]->newIndex);
 #endif
 }
 
@@ -776,7 +776,7 @@ static SmoothEdge *find_other_sharp_edge(SmoothVert *vert, SmoothEdge *edge, Lin
 	LinkNode *visited_edges = NULL;
 #ifdef EDGESPLIT_DEBUG_1
 	printf("=== START === find_other_sharp_edge(edge = %4d, vert = %4d)\n",
-		   edge->newIndex, vert->newIndex);
+			edge->newIndex, vert->newIndex);
 #endif
 
 	/* get a face on which to start */
@@ -800,7 +800,7 @@ static SmoothEdge *find_other_sharp_edge(SmoothVert *vert, SmoothEdge *edge, Lin
 			 && !linklist_contains(visited_edges, edge2)) {
 #ifdef EDGESPLIT_DEBUG_3
 		printf("current face %4d; current edge %4d\n", face->newIndex,
-			   edge2->newIndex);
+				edge2->newIndex);
 #endif
 		/* get the next face */
 		face = other_face(edge2, face);
@@ -818,26 +818,26 @@ static SmoothEdge *find_other_sharp_edge(SmoothVert *vert, SmoothEdge *edge, Lin
 			edge2 = other_edge(face, vert, edge2);
 #ifdef EDGESPLIT_DEBUG_3
 			printf("next face %4d; next edge %4d\n",
-				   face->newIndex, edge2->newIndex);
+					face->newIndex, edge2->newIndex);
 		} else {
 			printf("loose edge: %4d\n", edge2->newIndex);
 #endif
 		}
-			 }
+	}
 
-			 /* either we came back to the start edge or we found a sharp/loose edge */
-			 if(linklist_contains(visited_edges, edge2))
-				 /* we came back to the start edge */
-				 edge2 = NULL;
+	/* either we came back to the start edge or we found a sharp/loose edge */
+	if(linklist_contains(visited_edges, edge2))
+		/* we came back to the start edge */
+		edge2 = NULL;
 
-			 BLI_linklist_free(visited_edges, NULL);
+	BLI_linklist_free(visited_edges, NULL);
 
 #ifdef EDGESPLIT_DEBUG_1
-			 printf("=== END === find_other_sharp_edge(edge = %4d, vert = %4d), "
-					 "returning edge %d\n",
-	 edge->newIndex, vert->newIndex, edge2 ? edge2->newIndex : -1);
+	printf("=== END === find_other_sharp_edge(edge = %4d, vert = %4d), "
+					"returning edge %d\n",
+	edge->newIndex, vert->newIndex, edge2 ? edge2->newIndex : -1);
 #endif
-			 return edge2;
+	return edge2;
 }
 
 static void split_single_vert(SmoothVert *vert, SmoothFace *face,
@@ -911,7 +911,7 @@ static void propagate_split(SmoothEdge *edge, SmoothVert *vert,
 	LinkNode *visited_faces = NULL;
 #ifdef EDGESPLIT_DEBUG_1
 	printf("=== START === propagate_split(edge = %4d, vert = %4d)\n",
-		   edge->newIndex, vert->newIndex);
+			edge->newIndex, vert->newIndex);
 #endif
 
 	edge2 = find_other_sharp_edge(vert, edge, &visited_faces);
@@ -956,7 +956,7 @@ static void propagate_split(SmoothEdge *edge, SmoothVert *vert,
 	BLI_linklist_free(visited_faces, NULL);
 #ifdef EDGESPLIT_DEBUG_1
 	printf("=== END === propagate_split(edge = %4d, vert = %4d)\n",
-		   edge->newIndex, vert->newIndex);
+			edge->newIndex, vert->newIndex);
 #endif
 }
 
@@ -969,7 +969,7 @@ static void split_edge(SmoothEdge *edge, SmoothVert *vert, SmoothMesh *mesh)
 	LinkNode *visited_faces = NULL;
 #ifdef EDGESPLIT_DEBUG_1
 	printf("=== START === split_edge(edge = %4d, vert = %4d)\n",
-		   edge->newIndex, vert->newIndex);
+			edge->newIndex, vert->newIndex);
 #endif
 
 	edge2 = find_other_sharp_edge(vert, edge, &visited_faces);
@@ -1042,7 +1042,7 @@ static void split_edge(SmoothEdge *edge, SmoothVert *vert, SmoothMesh *mesh)
 	BLI_linklist_free(visited_faces, NULL);
 #ifdef EDGESPLIT_DEBUG_1
 	printf("=== END === split_edge(edge = %4d, vert = %4d)\n",
-		   edge->newIndex, vert->newIndex);
+			edge->newIndex, vert->newIndex);
 #endif
 }
 
@@ -1078,31 +1078,31 @@ static void tag_and_count_extra_edges(SmoothMesh *mesh, float split_angle,
 			/* (the edge can only be sharp if we're checking angle or flag,
 			* and it has at least 2 faces) */
 
-						 /* if we're checking the sharp flag and it's set, good */
-						 if((flags & MOD_EDGESPLIT_FROMFLAG) && (edge->flag & ME_SHARP)) {
-							 /* this edge is sharp */
-							 sharp = 1;
-
-							 (*extra_edges)++;
-						 } else if(flags & MOD_EDGESPLIT_FROMANGLE) {
-							 /* we know the edge has 2 faces, so check the angle */
-							 SmoothFace *face1 = edge->faces->link;
-							 SmoothFace *face2 = edge->faces->next->link;
-							 float edge_angle_cos = dot_v3v3(face1->normal,
-									 face2->normal);
-
-							 if(edge_angle_cos < threshold) {
-								 /* this edge is sharp */
-								 sharp = 1;
-
-								 (*extra_edges)++;
-							 }
-						 }
-					 }
+			/* if we're checking the sharp flag and it's set, good */
+			if((flags & MOD_EDGESPLIT_FROMFLAG) && (edge->flag & ME_SHARP)) {
+				/* this edge is sharp */
+				sharp = 1;
+
+				(*extra_edges)++;
+			} else if(flags & MOD_EDGESPLIT_FROMANGLE) {
+				/* we know the edge has 2 faces, so check the angle */
+				SmoothFace *face1 = edge->faces->link;
+				SmoothFace *face2 = edge->faces->next->link;
+				float edge_angle_cos = dot_v3v3(face1->normal,
+				face2->normal);
+
+				if(edge_angle_cos < threshold) {
+					/* this edge is sharp */
+					sharp = 1;
+
+					(*extra_edges)++;
+				}
+			}
+		}
 
-					 /* set/clear sharp flag appropriately */
-					 if(sharp) edge->flag |= ME_SHARP;
-					 else edge->flag &= ~ME_SHARP;
+		/* set/clear sharp flag appropriately */
+		if(sharp) edge->flag |= ME_SHARP;
+		else edge->flag &= ~ME_SHARP;
 	}
 }
 
@@ -1244,7 +1244,7 @@ static DerivedMesh *edgesplitModifier_do(EdgeSplitModifierData *emd, DerivedMesh
 #ifdef EDGESPLIT_DEBUG_0
 	printf("Edgesplit: Estimated %d verts & %d edges, "
 			"found %d verts & %d edges\n", max_verts, max_edges,
-   mesh->num_verts, mesh->num_edges);
+			mesh->num_verts, mesh->num_edges);
 #endif
 
 	result = CDDM_from_smoothmesh(mesh);
diff --git a/source/blender/modifiers/intern/MOD_explode.c b/source/blender/modifiers/intern/MOD_explode.c
index 00ab5d027fb..f1bc0d33fd8 100644
--- a/source/blender/modifiers/intern/MOD_explode.c
+++ b/source/blender/modifiers/intern/MOD_explode.c
@@ -997,19 +997,19 @@ static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
 
 			createFacepa(emd,psmd,derivedData);
 		}
-				 /* 2. create new mesh */
-				 if(emd->flag & eExplodeFlag_EdgeCut){
-					 int *facepa = emd->facepa;
-					 DerivedMesh *splitdm=cutEdges(emd,dm);
-					 DerivedMesh *explode=explodeMesh(emd, psmd, md->scene, ob, splitdm);
-
-					 MEM_freeN(emd->facepa);
-					 emd->facepa=facepa;
-					 splitdm->release(splitdm);
-					 return explode;
-				 }
-				 else
-					 return explodeMesh(emd, psmd, md->scene, ob, derivedData);
+		/* 2. create new mesh */
+		if(emd->flag & eExplodeFlag_EdgeCut){
+			int *facepa = emd->facepa;
+			DerivedMesh *splitdm=cutEdges(emd,dm);
+			DerivedMesh *explode=explodeMesh(emd, psmd, md->scene, ob, splitdm);
+
+			MEM_freeN(emd->facepa);
+			emd->facepa=facepa;
+			splitdm->release(splitdm);
+			return explode;
+		}
+		else
+			return explodeMesh(emd, psmd, md->scene, ob, derivedData);
 	}
 	return derivedData;
 }