prepare for flagging the bmesh has having invalid index values, so we can skip looping over all elements if its already valid.

- went over every BM_SetIndex call and added comments about its use, if its setting dirty values or correct ones.
- replace loops over all elements _just_ to set index values, with a new function, BM_ElemIndex_Ensure(...), this will eventually only initialize values when they are dirty.

source/blender/blenkernel/intern/cdderivedmesh.c

@@ -1997,11 +1997,6 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 	/*add tesselation mface layers*/
 	CustomData_from_bmeshpoly(&dm->faceData, &dm->polyData, &dm->loopData, em->tottri);
 
-	/* set vert index */
-	eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; eve=BMIter_Step(&iter), i++)
-		BM_SetIndex(eve, i);
-
 	index = dm->getVertDataArray(dm, CD_ORIGINDEX);
 
 	eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
@@ -2010,7 +2005,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 
 		copy_v3_v3(mv->co, eve->co);
 
-		BM_SetIndex(eve, i);
+		BM_SetIndex(eve, i); /* set_inline */
 
 		normal_float_to_short_v3(mv->no, eve->no);
 
@@ -2023,13 +2018,14 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 
 		CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
 	}
+	bm->elem_index_dirty &= ~BM_VERT;
 
 	index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
 	eed = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);
 	for (i=0; eed; eed=BMIter_Step(&iter), i++, index++) {
 		MEdge *med = &medge[i];
 
-		BM_SetIndex(eed, i);
+		BM_SetIndex(eed, i); /* set_inline */
 
 		med->v1 = BM_GetIndex(eed->v1);
 		med->v2 = BM_GetIndex(eed->v2);
@@ -2044,11 +2040,9 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 		CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
 		if (add_orig) *index = i;
 	}
+	bm->elem_index_dirty &= ~BM_EDGE;
 
-	efa = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL);
-	for (i=0; efa; i++, efa=BMIter_Step(&iter)) {
-		BM_SetIndex(efa, i);
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_FACE);
 
 	polyindex = dm->getTessFaceDataArray(dm, CD_POLYINDEX);
 	index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);

source/blender/blenkernel/intern/editderivedbmesh.c

@@ -402,10 +402,7 @@ static void bmDM_foreachMappedEdge(DerivedMesh *dm, void (*func)(void *userData,
 		BMVert *eve;
 		BMIter viter;
 
-		eve = BMIter_New(&viter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&viter), i++) {
-			BM_SetIndex(eve, i);
-		}
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
 
 		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
 		for(i=0; eed; i++,eed=BMIter_Step(&iter))
@@ -428,13 +425,8 @@ static void bmDM_drawMappedEdges(DerivedMesh *dm, int (*setDrawOptions)(void *us
 	int i;
 	
 	if (bmdm->vertexCos) {
-		BMVert *eve;
-		BMIter viter;
 
-		eve = BMIter_New(&viter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&viter), i++) {
-			BM_SetIndex(eve, i);
-		}
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
 
 		glBegin(GL_LINES);
 		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
@@ -472,11 +464,8 @@ static void bmDM_drawMappedEdgesInterp(DerivedMesh *dm, int (*setDrawOptions)(vo
 	int i;
 
 	if (bmdm->vertexCos) {
-		BMVert *eve;
 
-		eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++)
-			BM_SetIndex(eve, i);
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
 
 		glBegin(GL_LINES);
 		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
@@ -581,9 +570,7 @@ static void bmDM_foreachMappedFaceCenter(DerivedMesh *dm, void (*func)(void *use
 	int i;
 
 	if (bmdm->vertexCos) {
-		eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++)
-			BM_SetIndex(eve, i);
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
 	}
 
 	efa = BMIter_New(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL);
@@ -620,15 +607,8 @@ static void bmDM_drawMappedFaces(DerivedMesh *dm,
 		float (*vertexCos)[3]= bmdm->vertexCos;
 		float (*vertexNos)[3]= bmdm->vertexNos;
 		float (*faceNos)[3]=   bmdm->faceNos;
-		BMVert *eve;
 		
-		eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++)
-			BM_SetIndex(eve, i);
-
-		efa = BMIter_New(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL);
-		for (i=0; efa; efa=BMIter_Step(&iter), i++)
-			BM_SetIndex(efa, i);
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT | BM_FACE);
 
 		for (i=0; i<bmdm->tc->tottri; i++) {
 			BMLoop **l = bmdm->tc->looptris[i];
@@ -694,9 +674,7 @@ static void bmDM_drawMappedFaces(DerivedMesh *dm,
 			}
 		}
 	} else {
-		efa = BMIter_New(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL);
-		for (i=0; efa; efa=BMIter_Step(&iter), i++)
-			BM_SetIndex(efa, i);
+		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_FACE);
 
 		for (i=0; i<bmdm->tc->tottri; i++) {
 			BMLoop **l = bmdm->tc->looptris[i];
@@ -809,16 +787,12 @@ static void bmDM_drawFacesTex_common(DerivedMesh *dm,
 
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
-	
-	i = 0;
-	BM_ITER(efa, &iter, bm, BM_FACES_OF_MESH, NULL)
-		BM_SetIndex(efa, i++);
+
+	BM_ElemIndex_Ensure(bm, BM_FACE);
 
 	if (vertexCos) {
-		i = 0;
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
-			BM_SetIndex(eve, i++);
-				
+		BM_ElemIndex_Ensure(bm, BM_VERT);
+
 		glBegin(GL_TRIANGLES);
 		for (i=0; i<em->tottri; i++) {
 			BMLoop **ls = em->looptris[i];
@@ -891,10 +865,8 @@ static void bmDM_drawFacesTex_common(DerivedMesh *dm,
 		}
 		glEnd();
 	} else {
-		i = 0;
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
-			BM_SetIndex(eve, i++);
-				
+		BM_ElemIndex_Ensure(bm, BM_VERT);
+
 		for (i=0; i<em->tottri; i++) {
 			BMLoop **ls = em->looptris[i];
 			MTexPoly *tp= CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY);
@@ -1022,9 +994,7 @@ static void bmDM_drawMappedFacesGLSL(DerivedMesh *dm,
 
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
-	BM_ITER_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
-		 BM_SetIndex(eve, i);
-	}
+	BM_ElemIndex_Ensure(bm, BM_VERT | BM_FACE);
 
 #define PASSATTRIB(loop, eve, vert) {											\
 	if(attribs.totorco) {														\
@@ -1047,9 +1017,6 @@ static void bmDM_drawMappedFacesGLSL(DerivedMesh *dm,
 	}																			\
 	}
 	
-	BM_ITER_INDEX(efa, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
-		BM_SetIndex(efa, i);
-	}
 	
 	for (i=0, ltri=em->looptris[0]; i<em->tottri; i++, ltri += 3) {
 		int drawSmooth;
@@ -1150,9 +1117,7 @@ static void bmDM_drawMappedFacesMat(DerivedMesh *dm,
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
 
-	BM_ITER_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
-		 BM_SetIndex(eve, i);
-	}
+	BM_ElemIndex_Ensure(bm, BM_VERT);
 
 #define PASSATTRIB(loop, eve, vert) {											\
 	if(attribs.totorco) {														\
@@ -1405,12 +1370,9 @@ static void bmDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
 	BMIter iter;
 	BMVert *ev;
 	int has_bweight = CustomData_has_layer(&bm->edata, CD_BWEIGHT);
-	int i, has_crease = CustomData_has_layer(&bm->edata, CD_CREASE);
+	int has_crease = CustomData_has_layer(&bm->edata, CD_CREASE);
 
-	/* store vertex indices in tmp union */
-	ev = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; ev; ev=BMIter_Step(&iter), i++)
-		BM_SetIndex(ev, i);
+	BM_ElemIndex_Ensure(bm, BM_VERT);
 
 	ee = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);
 	for( ; ee; ee=BMIter_Step(&iter), edge_r++) {
@@ -1439,10 +1401,7 @@ static void bmDM_copyFaceArray(DerivedMesh *dm, MFace *face_r)
 	BMLoop **l;
 	int i;
 
-	/* store vertexes indices in tmp union */
-	i = 0;
-	BM_ITER(ev, &iter, bm, BM_VERTS_OF_MESH, NULL)
-		BM_SetIndex(ev, i++);
+	BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
 
 	for (i=0; i<bmdm->tc->tottri; i++, face_r++) {
 		l = bmdm->tc->looptris[i];
@@ -1467,21 +1426,10 @@ static void bmDM_copyLoopArray(DerivedMesh *dm, MLoop *loop_r)
 	/* EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm; */ /* UNUSED */
 	BMesh *bm = ((EditDerivedBMesh *)dm)->tc->bm;
 	BMIter iter, liter;
-	BMVert *v;
 	BMFace *f;
 	BMLoop *l;
-	BMEdge *e;
-	int i;
 
-	i = 0;
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, i++);
-	}
-
-	i = 0;
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-		BM_SetIndex(e, i++);
-	}
+	BM_ElemIndex_Ensure(bm, BM_VERT | BM_EDGE);
 
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
@@ -1714,12 +1662,10 @@ DerivedMesh *getEditDerivedBMesh(BMEditMesh *em, Object *UNUSED(ob),
 		BMIter iter;
 		int totface = bmdm->tc->tottri;
 		int i;
-		
-		eve=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++)
-			BM_SetIndex(eve, i);
 
-		bmdm->vertexNos = MEM_callocN(sizeof(*bmdm->vertexNos)*i, "bmdm_vno");
+		BM_ElemIndex_Ensure(bm, BM_VERT);
+
+		bmdm->vertexNos = MEM_callocN(sizeof(*bmdm->vertexNos) * bm->totvert, "bmdm_vno");
 		bmdm->faceNos = MEM_mallocN(sizeof(*bmdm->faceNos)*totface, "bmdm_vno");
 
 		for (i=0; i<bmdm->tc->tottri; i++) {

source/blender/bmesh/bmesh.h

@@ -154,6 +154,31 @@ BM_INLINE void BM_ClearHFlag(void *element, const char hflag);
 /*stuff for dealing BM_ToggleHFlag header flags*/
 BM_INLINE void BM_ToggleHFlag(void *element, const char hflag);
 BM_INLINE void BM_MergeHFlag(void *element_a, void *element_b);
+
+/* notes on BM_SetIndex(...) usage,
+ * Set index is sometimes abused as temp storage, other times we cant be
+ * sure if the index values are valid because certain operations have modified
+ * the mesh structure.
+ *
+ * To set the elements to valid indicies 'BM_ElemIndex_Ensure' should be used
+ * rather then adding inline loops, however there are cases where we still
+ * set the index directly
+ *
+ * In an attempt to manage this, here are 3 tags Im adding to uses of
+ * 'BM_SetIndex'
+ *
+ * - 'set_inline'  -- since the data is already being looped over set to a
+ *                    valid value inline.
+ *
+ * - 'set_dirty!'  -- intentionally sets the index to an invalid value,
+ *                    flagging 'bm->elem_index_dirty' so we dont use it.
+ *
+ * - 'set_ok'      -- this is valid use since the part of the code is low level.
+ *
+ * - 'set_loop'    -- currently loop index values are not used used much so
+ *                    assume each case they are dirty.
+ * - campbell */
+
 BM_INLINE void BM_SetIndex(void *element, const int index);
 BM_INLINE int BM_GetIndex(const void *element);
 

source/blender/bmesh/bmesh_class.h

@@ -123,6 +123,12 @@ typedef struct BMFlagLayer {
 typedef struct BMesh {
 	int totvert, totedge, totloop, totface;
 	int totvertsel, totedgesel, totfacesel;
+
+	/* flag index arrays as being dirty so we can check if they are clean and
+	 * avoid looping over the entire vert/edge/face array in those cases.
+	 * valid flags are - BM_VERT | BM_EDGE | BM_FACE.
+	 * BM_LOOP isnt handled so far. */
+	char elem_index_dirty;
 	
 	/*element pools*/
 	struct BLI_mempool *vpool, *epool, *lpool, *fpool;

source/blender/bmesh/intern/bmesh_construct.c

@@ -525,9 +525,12 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
 		v2 = BM_Make_Vert(bm, v->co, NULL); /* copy between meshes so cant use 'example' argument */
 		BM_Copy_Attributes(bmold, bm, v, v2);
 		vtable[i] = v2;
-		BM_SetIndex(v, i);
-		BM_SetIndex(v2, i);
+		BM_SetIndex(v, i); /* set_inline */
+		BM_SetIndex(v2, i); /* set_inline */
 	}
+	bmold->elem_index_dirty &= ~BM_VERT;
+	bm->elem_index_dirty &= ~BM_VERT;
+
 	/* safety check */
 	BLI_assert(i == bmold->totvert);
 	
@@ -538,14 +541,19 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
 
 		BM_Copy_Attributes(bmold, bm, e, e2);
 		etable[i] = e2;
-		BM_SetIndex(e, i);
-		BM_SetIndex(e2, i);
+		BM_SetIndex(e, i); /* set_inline */
+		BM_SetIndex(e2, i); /* set_inline */
 	}
+	bmold->elem_index_dirty &= ~BM_EDGE;
+	bm->elem_index_dirty &= ~BM_EDGE;
+
 	/* safety check */
 	BLI_assert(i == bmold->totedge);
 	
 	f = BMIter_New(&iter, bmold, BM_FACES_OF_MESH, NULL);
 	for (i=0; f; f=BMIter_Step(&iter), i++) {
+		BM_SetIndex(f, i); /* set_inline */
+
 		BLI_array_empty(loops);
 		BLI_array_empty(edges);
 		l = BMIter_New(&liter, bmold, BM_LOOPS_OF_FACE, f);
@@ -568,7 +576,6 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
 		if (!f2)
 			continue;
 
-		BM_SetIndex(f, i);
 		ftable[i] = f2;
 
 		BM_Copy_Attributes(bmold, bm, f, f2);
@@ -581,6 +588,9 @@ BMesh *BM_Copy_Mesh(BMesh *bmold)
 
 		if (f == bmold->act_face) bm->act_face = f2;
 	}
+	bmold->elem_index_dirty &= ~BM_FACE;
+	bm->elem_index_dirty &= ~BM_FACE;
+
 	/* safety check */
 	BLI_assert(i == bmold->totface);
 

source/blender/bmesh/intern/bmesh_mesh.c

@@ -270,15 +270,16 @@ void BM_Compute_Normals(BMesh *bm)
 	index = 0;
 	edgevec = MEM_callocN(sizeof(float) * 3 * bm->totedge, "BM normal computation array");
 	BM_ITER(e, &edges, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_SetIndex(e, index); /* set_inline */
 		if (!e->l) {
 			/* the edge vector will not be needed when the edge has no radial */
 			continue;
 		}
-		BM_SetIndex(e, index);
 		sub_v3_v3v3(edgevec[index], e->v2->co, e->v1->co);
 		normalize_v3(edgevec[index]);
 		index++;
 	}
+	bm->elem_index_dirty &= ~BM_EDGE;
 
 	/*add weighted face normals to vertices*/
 	BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
@@ -486,31 +487,88 @@ void BM_ElemIndex_Ensure(BMesh *bm, const char hflag)
 {
 	BMIter iter;
 	BMHeader *ele;
-	int index;
 
-	/* TODO, mark arrays as dirty, only calculate if needed! */
+	/* TODO, mark arrays as dirty, only calculate if needed!,
+	 * uncomment bm->elem_index_dirty checks */
 
-	if (hflag & BM_VERT) {
-		index= 0;
+	if ((hflag & BM_VERT) /* && (bm->elem_index_dirty & BM_VERT) */) {
+		int index= 0;
 		BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-			BM_SetIndex(ele, index);
+			BM_SetIndex(ele, index); /* set_ok */
 			index++;
 		}
+		bm->elem_index_dirty &= ~BM_VERT;
 	}
 
-	if (hflag & BM_EDGE) {
-		index= 0;
+	if ((hflag & BM_EDGE) /* && (bm->elem_index_dirty & BM_EDGE) */) {
+		int index= 0;
 		BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-			BM_SetIndex(ele, index);
+			BM_SetIndex(ele, index); /* set_ok */
 			index++;
 		}
+		bm->elem_index_dirty &= ~BM_EDGE;
 	}
 
-	if (hflag & BM_FACE) {
-		index= 0;
+	if ((hflag & BM_FACE) /* && (bm->elem_index_dirty & BM_FACES) */) {
+		int index= 0;
 		BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
-			BM_SetIndex(ele, index);
+			BM_SetIndex(ele, index); /* set_ok */
 			index++;
 		}
+		bm->elem_index_dirty &= ~BM_FACE;
 	}
 }
+
+
+/* array checking/setting macros */
+/* currently vert/edge/loop/face index data is being abused, but we should
+ * eventually be able to rely on it being valid. To this end are macro's
+ * that validate them (so blender doesnt crash), but also print errors so we can
+ * fix the offending parts of the code, this way after some months we can
+ * confine this code for debug mode.
+ *
+ *
+ */
+
+void BM_ElemIndex_Validate(BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b)
+{
+	BMIter iter;
+	BMHeader *ele;
+	int types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
+	const char *type_names[3]= {"vert", "edge", "face"};
+	int i;
+	int is_any_error= 0;
+
+	for (i=0; i<3; i++) {
+		int index= 0;
+		int is_error= 0;
+		int err_val= 0;
+		int err_idx= 0;
+
+		BM_ITER(ele, &iter, bm, types[i], NULL) {
+			if (BM_GetIndex(ele) != index) {
+				err_val= BM_GetIndex(ele);
+				err_idx= index;
+				is_error= 1;
+			}
+
+			BM_SetIndex(ele, index); /* set_ok */
+			index++;
+		}
+
+		if (is_error) {
+			is_any_error= 1;
+			fprintf(stderr,
+			        "Invalid Index: at %s, %s, %s[%d] invalid index %d, '%s', '%s'\n",
+			        location, func, type_names[i], err_idx, err_val, msg_a, msg_b);
+		}
+	}
+
+#ifdef DEBUG
+	if (is_any_error == 0) {
+		fprintf(stderr,
+				"Valid Index Success: at %s, %s, '%s', '%s'\n",
+				location, func, msg_a, msg_b);
+	}
+#endif
+}

source/blender/bmesh/intern/bmesh_newcore.c

@@ -23,7 +23,7 @@ BMVert *BM_Make_Vert(BMesh *bm, float co[3], const struct BMVert *example)
 {
 	BMVert *v = BLI_mempool_calloc(bm->vpool);
 
-	BM_SetIndex(v, bm->totvert);
+	BM_SetIndex(v, bm->totvert); /* set_ok */
 
 	bm->totvert += 1;
 
@@ -79,7 +79,7 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, i
 	
 	e = BLI_mempool_calloc(bm->epool);
 
-	BM_SetIndex(e, bm->totedge);
+	BM_SetIndex(e, bm->totedge); /* set_ok */
 
 	bm->totedge += 1;
 
@@ -228,7 +228,7 @@ BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, int len, int nod
 	
 	f = BLI_mempool_calloc(bm->fpool);
 
-	BM_SetIndex(f, bm->totface);
+	BM_SetIndex(f, bm->totface); /* set_ok */
 
 	bm->totface += 1;
 
@@ -1587,7 +1587,7 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
 		   the edges & faces and assign an index to each connected set */
 		while ((e = BLI_array_pop(stack))) {
 			BLI_ghash_insert(visithash, e, SET_INT_IN_POINTER(maxindex));
-			BM_SetIndex(e, maxindex);
+			BM_SetIndex(e, maxindex); /* set_dirty! */ /* BMESH_TODO, check the indexs are is invalid after this function runs */
 
 			BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
 				nl = (l->v == v) ? l->prev : l->next;
@@ -1599,6 +1599,7 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
 
 		maxindex++;
 	}
+	em->bm->elem_index_dirty |= BM_EDGE;
 
 	/* Make enough verts to split v for each group */
 	verts = MEM_callocN(sizeof(BMVert *) * maxindex, "bmesh_cutvert");

source/blender/bmesh/intern/bmesh_polygon.c

@@ -753,11 +753,13 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3],
 	l = bm_firstfaceloop(f);
 	do{
 		copy_v3_v3(projectverts[i], l->v->co);
-		BM_SetIndex(l->v, i);
+		BM_SetIndex(l->v, i); /* set dirty! */
 		i++;
 		l = l->next;
 	}while(l != bm_firstfaceloop(f));
-	
+
+	bm->elem_index_dirty |= BM_VERT; /* see above */
+
 	///bmesh_update_face_normal(bm, f, projectverts);
 
 	compute_poly_normal(f->no, projectverts, f->len);
@@ -854,7 +856,7 @@ void BM_LegalSplits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len)
 	i = 0;
 	l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
 	for (; l; l=BMIter_Step(&iter)) {
-		BM_SetIndex(l, i);
+		BM_SetIndex(l, i); /* set_loop */
 		copy_v3_v3(projverts[i], l->v->co);
 		i++;
 	}

source/blender/bmesh/operators/createops.c

@@ -544,7 +544,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
 			continue;
 		
 		//cv = BM_Make_Vert(bm, cent, v);
-		//BM_SetIndex(cv, -1);
+		//BM_SetIndex(cv, -1);  /* set_dirty! */
 		i = 0;
 		e = vdata[BM_GetIndex(v)].e;
 		lastv = NULL;
@@ -565,7 +565,7 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
 			add_v3_v3(co, vdata[BM_GetIndex(v)].offco);
 			
 			v2 = BM_Make_Vert(bm, co, NULL);
-			BM_SetIndex(v2, -1);
+			BM_SetIndex(v2, -1); /* set_dirty! */
 			//BM_Make_Edge(bm, cv, v2, NULL, 0);
 			
 			BM_Select(bm, v2, 1);
@@ -850,11 +850,7 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 	BMO_Flag_Buffer(bm, op, "edges", EDGE_MARK, BM_EDGE);
 	BMO_Flag_Buffer(bm, op, "excludefaces", FACE_IGNORE, BM_FACE);
 	
-	i = 0;
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, i);
-		i++;	
-	}
+	BM_ElemIndex_Ensure(bm, BM_VERT);
 
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		BMO_SetFlag(bm, f, ELE_ORIG);
@@ -862,14 +858,15 @@ void bmesh_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 
 	i = 0;
 	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-		BM_SetIndex(e, i);
+		BM_SetIndex(e, i); /* set_inline */
 		
 		if (!BMO_TestFlag(bm, e, EDGE_MARK)) {
 			edata[i].tag = 2;
 		}
 
-		i += 1;
+		i++;
 	}
+	bm->elem_index_dirty &= ~BM_EDGE;
 
 	init_rotsys(bm, edata, vdata);
 	

source/blender/bmesh/operators/edgesplitop.c

@@ -102,7 +102,7 @@ static BMFace *remake_face(BMesh *bm, EdgeTag *etags, BMFace *f, BMVert **verts,
 		if (l->e != l2->e) {
 			/*set up data for figuring out the two sides of
 			  the splits*/
-			BM_SetIndex(l2->e, BM_GetIndex(l->e));
+			BM_SetIndex(l2->e, BM_GetIndex(l->e)); /* set_dirty! */ /* BMESH_TODO, double check this is being set dirty - campbell */
 			et = etags + BM_GetIndex(l->e);
 			
 			if (!et->newe1) {
@@ -128,6 +128,7 @@ static BMFace *remake_face(BMesh *bm, EdgeTag *etags, BMFace *f, BMVert **verts,
 		BMO_SetFlag(bm, l->e, EDGE_MARK);
 		BMO_SetFlag(bm, l2->e, EDGE_MARK);
 	}
+	bm->elem_index_dirty |= BM_EDGE; /* double check this, see above */
 
 	return f2;
 }
@@ -247,12 +248,8 @@ void bmesh_edgesplitop_exec(BMesh *bm, BMOperator *op)
 	}
 
 	etags = MEM_callocN(sizeof(EdgeTag)*bm->totedge, "EdgeTag");
-	
-	i = 0;
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-		BM_SetIndex(e, i);
-		i++;
-	}
+
+	BM_ElemIndex_Ensure(bm, BM_EDGE);
 
 #ifdef ETV
 #  undef ETV

source/blender/bmesh/operators/extrudeops.c

@@ -355,11 +355,7 @@ static void calc_solidify_normals(BMesh *bm)
 		BM_SetHFlag(v, BM_TMP_TAG);
 	}
 
-	/* todo - replace with func! */
-	i= 0;
-	BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
-		BM_SetIndex(e, i++);
-	}
+	BM_ElemIndex_Ensure(bm, BM_EDGE);
 
 	BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 		if (!BMO_TestFlag(bm, f, FACE_MARK)) {
@@ -509,11 +505,7 @@ static void solidify_add_thickness(BMesh *bm, float dist)
 	float *angles = NULL;
 	BLI_array_staticdeclare(angles, 16);
 
-	/* BMESH_TODO, remove this when we are sure the array will be valid */
-	i = 0;
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, i++);
-	}
+	BM_ElemIndex_Ensure(bm, BM_VERT);
 
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		if(!BMO_TestFlag(bm, f, FACE_MARK)) {

source/blender/bmesh/operators/mesh_conv.c

@@ -131,7 +131,6 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 		normal_short_to_float_v3(v->no, mvert->no);
 
 		vt[i] = v;
-		BM_SetIndex(v, i);
 
 		/*transfer flags*/
 		v->head.hflag = MEFlags_To_BMFlags(mvert->flag, BM_VERT);
@@ -242,7 +241,7 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 		j = 0;
 		BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
 			/* Save index of correspsonding MLoop */
-			BM_SetIndex(l, mpoly->loopstart+j);
+			BM_SetIndex(l, mpoly->loopstart+j); /* set_loop */
 		}
 
 		/*Copy Custom Data*/
@@ -261,7 +260,7 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 				int li = BM_GetIndex(l);
 				CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
-				BM_SetIndex(l, 0);
+				BM_SetIndex(l, 0); /* set_loop */
 			}
 		}
 	}
@@ -503,7 +502,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 		
 		mvert->flag = BMFlags_To_MEFlags(v);
 
-		BM_SetIndex(v, i);
+		BM_SetIndex(v, i); /* set_inline */
 
 		/*copy over customdata*/
 		CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
@@ -513,6 +512,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 
 		BM_CHECK_ELEMENT(bm, v);
 	}
+	bm->elem_index_dirty &= ~BM_VERT;
 
 	i = 0;
 	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
@@ -526,7 +526,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 		
 		medge->flag = BMFlags_To_MEFlags(e);
 		
-		BM_SetIndex(e, i);
+		BM_SetIndex(e, i); /* set_inline */
 
 		/*copy over customdata*/
 		CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
@@ -535,6 +535,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 		medge++;
 		BM_CHECK_ELEMENT(bm, e);
 	}
+	bm->elem_index_dirty &= ~BM_EDGE;
 
 	/*new scanfill tesselation code*/
 	if (dotess) {
@@ -549,7 +550,7 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 				eve = BLI_addfillvert(l->v->co);
 				eve->tmp.p = l;
 				
-				BM_SetIndex(l, i);
+				BM_SetIndex(l, i); /* set_loop */
 
 				if (lasteve) {
 					BLI_addfilledge(lasteve, eve);

source/blender/bmesh/operators/mirror.c

@@ -73,11 +73,12 @@ void bmesh_mirror_exec(BMesh *bm, BMOperator *op)
 		BLI_array_growone(vmap);
 		vmap[i] = v;
 
-		BM_SetIndex(v2, i);
+		BM_SetIndex(v2, i); /* set_dirty! */ /*BMESH_TODO, double check this is being made dirty, 99% sure it is - campbell */
 		v2 = BMIter_Step(&iter);
 
-		i += 1;
+		i++;
 	}
+	bm->elem_index_dirty |= BM_VERT;
 
 	/*feed old data to transform bmop*/
 	scale[axis] = -1.0f;

source/blender/bmesh/operators/removedoubles.c

@@ -125,14 +125,15 @@ void bmesh_weldverts_exec(BMesh *bm, BMOperator *op)
 
 	/* BMESH_TODO, stop abusing face index here */
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
-		BM_SetIndex(f, 0);
+		BM_SetIndex(f, 0); /* set_dirty! */
 		BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 			if (BMO_TestFlag(bm, l->v, ELE_DEL))
 				BMO_SetFlag(bm, f, FACE_MARK|ELE_DEL);
 			if (BMO_TestFlag(bm, l->e, EDGE_COL)) 
-				BM_SetIndex(f, BM_GetIndex(f)+1);
+				BM_SetIndex(f, BM_GetIndex(f)+1); /* set_dirty! */
 		}
 	}
+	bm->elem_index_dirty |= BM_FACE;
 
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		if (!BMO_TestFlag(bm, f, FACE_MARK))

source/blender/bmesh/operators/utils.c

@@ -1232,9 +1232,10 @@ void bmesh_vertexshortestpath_exec(BMesh *bm, BMOperator *op)
 		vert_list[i].v = v;
 		vert_list[i].parent = NULL;
 		vert_list[i].weight = FLT_MAX;
-		BM_SetIndex(v, i);
+		BM_SetIndex(v, i); /* set_inline */
 		i++;
 	}
+	bm->elem_index_dirty &= ~BM_VERT;
 
 	/*
 	** we now have everything we need, start Dijkstra path finding algorithm

source/blender/editors/mesh/bmesh_select.c

@@ -1217,21 +1217,19 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
 
 	BLI_smallhash_init(&visithash);
 
-	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-	/* we need the vert */
-	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, totvert);
-		totvert++;
-	}
+	/* note, would pass BM_EDGE except we are looping over all edges anyway */
+	BM_ElemIndex_Ensure(em->bm, BM_VERT /* | BM_EDGE */ );
 
 	BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
 		e->head.flags[0].f = 0;
 		if (BM_TestHFlag(e, BM_HIDDEN)) {
 			BLI_smallhash_insert(&visithash, (uintptr_t)e, NULL);
 		}
-		BM_SetIndex(e, totedge);
+
+		BM_SetIndex(e, totedge); /* set_inline */
 		totedge++;
 	}
+	em->bm->elem_index_dirty &= ~BM_EDGE;
 
 	/* alloc */
 	nedges = MEM_callocN(sizeof(*nedges)*totvert+1, "SeamPathNEdges");

source/blender/editors/mesh/bmeshutils.c

@@ -630,14 +630,9 @@ UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_a
 	if (do_face_idx_array)
 		EDBM_init_index_arrays(em, 0, 0, 1);
 
-	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-	/* we need the vert */
-	totverts=0;
-	BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(ev, totverts);
-		totverts++;
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 	
+	totverts= em->bm->totvert;
 	totuv = 0;
 
 	/* generate UvMapVert array */
@@ -827,15 +822,7 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select)
 
 	em->bm->vdata.layers[li].flag |= CD_FLAG_TEMPORARY;
 
-	/* BMESH_TODO, we should STOP overwriting the vertex index data with bad
-	 * indicies, once createTransEditVerts() stops doing this, this loop can be
-	 * removed - campbell */
-	i= 0;
-	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, i++);
-	}
-	/* END BMESH_TODO */
-
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 
 	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
 		BMVert *mirr;

source/blender/editors/mesh/editbmesh_bvh.c

@@ -157,9 +157,11 @@ BMBVHTree *BMBVH_NewBVH(BMEditMesh *em, int flag, Scene *scene, Object *obedit)
 		
 		tree->cos = MEM_callocN(sizeof(float)*3*em->bm->totvert, "bmbvh cos");
 		BM_ITER_INDEX(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL, i) {
-			BM_SetIndex(v, i);
+			BM_SetIndex(v, i); /* set_inline */
 			copy_v3_v3(tree->cos[i], v->co);
 		}
+		em->bm->elem_index_dirty &= ~BM_VERT;
+
 
 		cage = editbmesh_get_derived_cage_and_final(scene, obedit, em, &final, CD_MASK_DERIVEDMESH);
 		cagecos = MEM_callocN(sizeof(float)*3*em->bm->totvert, "bmbvh cagecos");

source/blender/editors/mesh/knifetool.c

@@ -1366,10 +1366,13 @@ static void remerge_faces(knifetool_opdata *kcd)
 			f2 = BM_Join_Faces(bm, faces, BLI_array_count(faces));
 			if (f2)  {
 				BMO_SetFlag(bm, f2, FACE_NEW);
-				BM_SetIndex(f2, idx);
+				BM_SetIndex(f2, idx); /* set_dirty! */ /* BMESH_TODO, check if this is valid or not */
 			}
 		}
 	}
+	/* BMESH_TODO, check if the code above validates the indicies */
+	/* bm->elem_index_dirty &= ~BM_FACE; */
+	bm->elem_index_dirty |= BM_FACE;
 
 	BLI_array_free(stack);
 	BLI_array_free(faces);
@@ -1399,10 +1402,11 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
 	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
 	i = 0;
 	BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
-		BM_SetIndex(f, i);
+		BM_SetIndex(f, i); /* set_inline */
 		faces[i] = f;
 		i++;
 	}
+	bm->elem_index_dirty &= ~BM_FACE;
 	
 	BM_ITER(e, &bmiter, bm, BM_EDGES_OF_MESH, NULL) {
 		BMO_SetFlag(bm, e, BOUNDARY);
@@ -1568,10 +1572,10 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
 			} while (l != bm_firstfaceloop(f2));
 	
 			BMO_ClearFlag(bm, f2, DEL);
-			BM_SetIndex(f2, i);
-			
+			BM_SetIndex(f2, i); /* set_dirty! */ /* note, not 100% sure this is dirty? need to check */
+
 			BM_Face_UpdateNormal(bm, f2);
-			if (dot_v3v3(f->no, f2->no) < 0.0) {
+			if (dot_v3v3(f->no, f2->no) < 0.0f) {
 				BM_flip_normal(bm, f2);
 			}
 		}
@@ -1579,13 +1583,14 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
 		BLI_end_edgefill();
 		BLI_smallhash_release(hash);
 	}
+	bm->elem_index_dirty |= BM_FACE;
 	
 	/* interpolate customdata */
 	BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
 		BMLoop *l1;
 		BMFace *f2; 
 		BMIter liter1;
-		
+
 		if (!BMO_TestFlag(bm, f, FACE_NEW))
 			continue;
 		
@@ -1600,7 +1605,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
 			BM_loop_interp_from_face(bm, l1, f2, 1, 1);
 		}
 	}
-	
+
 	/*merge triangles back into faces*/
 	remerge_faces(kcd);
 
@@ -1718,9 +1723,6 @@ static int knifetool_init(bContext *C, wmOperator *op, int UNUSED(do_cut))
 	Object *obedit = CTX_data_edit_object(C);
 	DerivedMesh *cage, *final;
 	SmallHash shash;
-	BMIter iter;
-	BMVert *v;
-	int i;
 	void *data[3];
 	
 	/* alloc new customdata */
@@ -1734,10 +1736,8 @@ static int knifetool_init(bContext *C, wmOperator *op, int UNUSED(do_cut))
 	em_setup_viewcontext(C, &kcd->vc);
 
 	kcd->em= ((Mesh *)kcd->ob->data)->edit_btmesh;
-	
-	BM_ITER_INDEX(v, &iter, kcd->em->bm, BM_VERTS_OF_MESH, NULL, i) {
-		BM_SetIndex(v, i);
-	}
+
+	BM_ElemIndex_Ensure(kcd->em->bm, BM_VERT);
 
 	cage = editbmesh_get_derived_cage_and_final(scene, obedit, kcd->em, &final, CD_MASK_DERIVEDMESH);
 	kcd->cagecos = MEM_callocN(sizeof(float)*3*kcd->em->bm->totvert, "knife cagecos");

source/blender/editors/mesh/meshtools.c

@@ -964,13 +964,9 @@ long mesh_mirrtopo_table(Object *ob, char mode)
 		}
 
 		if(em) {
-			BMVert *eve;
+			BM_ElemIndex_Ensure(em->bm, BM_VERT);
 
-			totvert= 0;
-			BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-				BM_SetIndex(eve, totvert);
-				totvert++;
-			}
+			totvert= em->bm->totvert;
 		}
 		else {
 			totvert = me->totvert;

source/blender/editors/object/object_vgroup.c

@@ -1389,12 +1389,9 @@ static void vgroup_blend(Object *ob)
 
 		def_nr= ob->actdef-1;
 
-		i= 0;
-		BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-			BM_SetIndex(eve, i);
-			i++;
-		}
-		dvert_tot= i;
+		BM_ElemIndex_Ensure(em->bm, BM_VERT);
+
+		dvert_tot= em->bm->totvert;
 
 		vg_weights= MEM_callocN(sizeof(float)*dvert_tot, "vgroup_blend_f");
 		vg_users= MEM_callocN(sizeof(int)*dvert_tot, "vgroup_blend_i");

source/blender/editors/space_view3d/view3d_snap.c

@@ -234,26 +234,31 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 		void *userdata[2] = {em, NULL};
 		/*int proptrans= 0; */ /*UNUSED*/
 		
+		/* abuses vertex index all over, set, just set dirty here,
+		 * perhaps this could use its own array instead? - campbell */
+
 		// transform now requires awareness for select mode, so we tag the f1 flags in verts
 		tottrans= 0;
 		if(em->selectmode & SCE_SELECT_VERTEX) {
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				if(!BM_TestHFlag(eve, BM_HIDDEN) && BM_TestHFlag(eve, BM_SELECT)) {
-					BM_SetIndex(eve, 1);
+					BM_SetIndex(eve, 1); /* set_dirty! */
 					tottrans++;
 				}
-				else BM_SetIndex(eve, 0);
+				else BM_SetIndex(eve, 0); /* set_dirty! */
 			}
 		}
 		else if(em->selectmode & SCE_SELECT_EDGE) {
 			BMEdge *eed;
 
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
-				BM_SetIndex(eve, 0);
+				BM_SetIndex(eve, 0); /* set_dirty! */
 
 			BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-				if(!BM_TestHFlag(eed, BM_HIDDEN) && BM_TestHFlag(eed, BM_SELECT))
-					BM_SetIndex(eed->v1, 1), BM_SetIndex(eed->v2, 1);
+				if(!BM_TestHFlag(eed, BM_HIDDEN) && BM_TestHFlag(eed, BM_SELECT)) {
+					BM_SetIndex(eed->v1, 1); /* set_dirty! */
+					BM_SetIndex(eed->v2, 1); /* set_dirty! */
+				}
 			}
 
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
@@ -263,7 +268,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 			BMFace *efa;
 
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
-				BM_SetIndex(eve, 0);
+				BM_SetIndex(eve, 0); /* set_dirty! */
 
 			BM_ITER(efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				if(!BM_TestHFlag(efa, BM_HIDDEN) && BM_TestHFlag(efa, BM_SELECT)) {
@@ -271,7 +276,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 					BMLoop *l;
 					
 					BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
-						BM_SetIndex(l->v, 1);
+						BM_SetIndex(l->v, 1); /* set_dirty! */
 					}
 				}
 			}
@@ -279,6 +284,8 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
 				if(BM_GetIndex(eve)) tottrans++;
 		}
+		/* for any of the 3 loops above which all dirty the indicies */
+		bm->elem_index_dirty |= BM_VERT;
 		
 		/* and now make transverts */
 		if(tottrans) {
@@ -287,7 +294,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 			a = 0;
 			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				if(BM_GetIndex(eve)) {
-					BM_SetIndex(eve, a);
+					BM_SetIndex(eve, a); /* set_dirty! */
 					copy_v3_v3(tv->oldloc, eve->co);
 					tv->loc= eve->co;
 					if(eve->no[0] != 0.0f || eve->no[1] != 0.0f ||eve->no[2] != 0.0f)
@@ -295,9 +302,10 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
 					tv->flag= BM_GetIndex(eve) & SELECT;
 					tv++;
 					a++;
-				} else BM_SetIndex(eve, -1);
+				} else BM_SetIndex(eve, -1); /* set_dirty! */
 			}
-			
+			/* set dirty already, above */
+
 			userdata[1] = transvmain;
 		}
 		

source/blender/editors/transform/transform_conversions.c

@@ -1840,13 +1840,10 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
 	BMIter viter;
 	int i, start;
 	
-	i = 0;
-	BM_ITER(v, &viter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, i);
-		dists[i] = FLT_MAX;
-		i++;
-	}
-	
+	fill_vn(dists, em->bm->totvert, FLT_MAX);
+
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
+
 	BLI_smallhash_init(visit);
 
 	BM_ITER(v, &viter, em->bm, BM_VERTS_OF_MESH, NULL) {

source/blender/editors/util/crazyspace.c

@@ -146,13 +146,8 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped
 	int *vert_table = MEM_callocN(sizeof(int)*em->bm->totvert, "vert_table");
 	int index = 0;
 
-	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(v, index);
-		index++;
-	}
-	
-	index = 0;
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
+
 	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
 		if (!BM_TestHFlag(v, BM_SELECT) || BM_TestHFlag(v, BM_HIDDEN))
 			continue;
@@ -179,17 +174,16 @@ void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mapped
 		}
 	}
 
-	/* BMESH_TODO, don't overwrite invalid index info! */
-
 	index = 0;
 	BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
 		if (vert_table[index] != 0)
-			BM_SetIndex(v, vert_table[index]-1);
+			BM_SetIndex(v, vert_table[index]-1); /* set_dirty! */
 		else
-			BM_SetIndex(v, -1);
+			BM_SetIndex(v, -1); /* set_dirty! */
 		
 		index++;
 	}
+	em->bm->elem_index_dirty |= BM_VERT;
 
 	MEM_freeN(vert_table);
 #if 0

source/blender/editors/uvedit/uvedit_ops.c

@@ -665,11 +665,7 @@ static void find_nearest_uv_edge(Scene *scene, Image *ima, BMEditMesh *em, float
 	mindist= 1e10f;
 	memset(hit, 0, sizeof(*hit));
 
-	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-	eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; eve=BMIter_Step(&iter), i++) {
-		BM_SetIndex(eve, i);
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 	
 	BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
 		tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
@@ -811,10 +807,7 @@ static void find_nearest_uv_vert(Scene *scene, Image *ima, BMEditMesh *em,
 	mindist= 1e10f;
 	memset(hit, 0, sizeof(*hit));
 	
-	eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; eve=BMIter_Step(&iter), i++) {
-		BM_SetIndex(eve, i);
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 
 	BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
 		tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
@@ -981,7 +974,6 @@ static int uv_edge_tag_faces(BMEditMesh *em, UvMapVert *first1, UvMapVert *first
 
 static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit *hit, float limit[2], int extend)
 {
-	BMVert *eve;
 	BMFace *efa;
 	BMIter iter, liter;
 	BMLoop *l;
@@ -994,12 +986,7 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit
 	EDBM_init_index_arrays(em, 0, 0, 1);
 	vmap= EDBM_make_uv_vert_map(em, 0, 0, limit);
 
-	/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-	count = 0;
-	BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(eve, count);
-		count++;
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 
 	count = 0;
 	BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
@@ -1009,11 +996,11 @@ static int select_edgeloop(Scene *scene, Image *ima, BMEditMesh *em, NearestHit
 		
 		BMO_ClearFlag(em->bm, efa, EFA_F1_FLAG);
 
-		/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-		BM_SetIndex(efa, count);
+		BM_SetIndex(efa, count); /* set_inline */
 
 		count++;
 	}
+	em->bm->elem_index_dirty &= ~BM_FACE;
 
 	/* set flags for first face and verts */
 	nverts= hit->efa->len;
@@ -1652,17 +1639,10 @@ static int stitch_exec(bContext *C, wmOperator *op)
 	}
 	else {
 		UVVertAverage *uv_average, *uvav;
-		int count;
 
-		/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-		// index and count verts
-		count=0;
-		BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-			BM_SetIndex(eve, count);
-			count++;
-		}
-		
-		uv_average= MEM_callocN(sizeof(UVVertAverage)*count, "Stitch");
+		BM_ElemIndex_Ensure(em->bm, BM_VERT);
+
+		uv_average= MEM_callocN(sizeof(UVVertAverage)*em->bm->totvert, "Stitch");
 		
 		// gather uv averages per vert
 		BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
@@ -2052,14 +2032,8 @@ static int mouse_select(bContext *C, float co[2], int extend, int loop)
 
 		/* (de)select sticky uv nodes */
 		if(sticky != SI_STICKY_DISABLE) {
-			BMVert *ev;
 
-			/* BMESH_TODO this should be valid now, leaving here until we can ensure this - campbell */
-			a = 0;
-			BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-				BM_SetIndex(ev, a);
-				a++;
-			}
+			BM_ElemIndex_Ensure(em->bm, BM_VERT);
 
 			/* deselect */
 			if(select==0) {
@@ -2885,7 +2859,8 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe
 
 	/* set all verts to -1 : an unused index*/
 	BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL)
-		BM_SetIndex(eve, -1);
+		BM_SetIndex(eve, -1); /* set_dirty! */
+	em->bm->elem_index_dirty |= BM_VERT;
 	
 	/* index every vert that has a selected UV using it, but only once so as to
 	 * get unique indices and to count how much to malloc */
@@ -2901,11 +2876,12 @@ static int snap_uvs_to_adjacent_unselected(Scene *scene, Image *ima, Object *obe
 		change = 1;
 		BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
 			if (uvedit_uv_selected(em, scene, l) && BM_GetIndex(l->v) == -1) {
-				BM_SetIndex(l->v, count);
+				BM_SetIndex(l->v, count); /* set_dirty! */
 				count++;
 			}
 		}
 	}
+	em->bm->elem_index_dirty |= BM_VERT; /* set above but include for completeness since they are made dirty again */
 	
 	coords = MEM_callocN(sizeof(float)*count*2, "snap to adjacent coords");
 	usercount = MEM_callocN(sizeof(short)*count, "snap to adjacent counts");

source/blender/editors/uvedit/uvedit_unwrap_ops.c

@@ -207,11 +207,7 @@ static ParamHandle *construct_param_handle(Scene *scene, BMEditMesh *em,
 	}
 	
 	/* we need the vert indices */
-	a = 0;
-	BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-		BM_SetIndex(ev, a);
-		a++;
-	}
+	BM_ElemIndex_Ensure(em->bm, BM_VERT);
 	
 	BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
 		EditVert *v, *lastv, *firstv;

source/blender/modifiers/intern/MOD_array.c

@@ -432,14 +432,18 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 
 			i = 0;
 			BMO_ITER(h, &oiter, em->bm, &op, "geom", BM_ALL) {
-				BM_SetIndex(h, i);
+				BM_SetIndex(h, i); /* set_dirty */
 				i++;
 			}
 
 			BMO_ITER(h, &oiter, em->bm, &op, "newout", BM_ALL) {
-				BM_SetIndex(h, i);
+				BM_SetIndex(h, i); /* set_dirty */
 				i++;
 			}
+			/* above loops over all, so set all to dirty, if this is somehow
+			 * setting valid values, this line can be remvoed - campbell */
+			em->bm->elem_index_dirty |= BM_VERT | BM_EDGE | BM_FACE;
+
 
 			BMO_Exec_Op(em->bm, &findop);