code refactor, function renaming for bmesh.

These changes are to make the bmesh api more consistent and easier to learn, grouping similar functions which is convenient for autocomplete.
This uses similar convention to RNA. 

* use face/loop/edge/vert as a prefix for functions.
* use 'elem' as a prefix too for functions that can take any type with a BMHeader.
* changed from camel case to underscore separated (like RNA).

7 files changed, 200 insertions, 200 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 825c2219cd1..0697951cc13 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -763,8 +763,8 @@ static float *get_editbmesh_orco_verts(BMEditMesh *em)
 	
 	orco = MEM_mallocN(sizeof(float)*3*totvert, "EditMesh Orco");
 
-	eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-	for (a=0; eve; eve=BMIter_Step(&iter), a+=3) {
+	eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
+	for (a=0; eve; eve=BM_iter_step(&iter), a+=3) {
 		copy_v3_v3(orco+a, eve->co);
 	}
 	
@@ -1709,8 +1709,8 @@ float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *numVerts_r))[3]
 
 	cos = MEM_mallocN(sizeof(float)*3*numVerts, "vertexcos");
 
-	eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; eve=BMIter_Step(&iter), i++) {
+	eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
+	for (i=0; eve; eve=BM_iter_step(&iter), i++) {
 		copy_v3_v3(cos[i], eve->co);
 	}
 
diff --git a/source/blender/blenkernel/intern/bvhutils.c b/source/blender/blenkernel/intern/bvhutils.c
index 5d2392b790d..5c50c14f1a8 100644
--- a/source/blender/blenkernel/intern/bvhutils.c
+++ b/source/blender/blenkernel/intern/bvhutils.c
@@ -619,14 +619,14 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float
 						/*Start with the assumption the triangle should be included for snapping.*/
 						insert = 1;
 
-						if (BM_TestHFlag(f, BM_ELEM_SELECT) || BM_TestHFlag(f, BM_ELEM_HIDDEN)) {
+						if (BM_elem_flag_test(f, BM_ELEM_SELECT) || BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
 							/*Don't insert triangles tesselated from faces that are hidden
 							  or selected*/
 							insert = 0;
 						}
 						else {
 							BM_ITER(v, &iter, em->bm, BM_VERTS_OF_FACE, f) {
-								if (BM_TestHFlag(v, BM_ELEM_SELECT)) {
+								if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
 									/*Don't insert triangles tesselated from faces that have
 									  any selected verts.*/
 									insert = 0;
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 00d7f6e2a1f..97340ff8572 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -2042,20 +2042,20 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 
 	index = dm->getVertDataArray(dm, CD_ORIGINDEX);
 
-	eve = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; eve=BMIter_Step(&iter), i++, index++) {
+	eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
+	for (i=0; eve; eve=BM_iter_step(&iter), i++, index++) {
 		MVert *mv = &mvert[i];
 
 		copy_v3_v3(mv->co, eve->co);
 
-		BM_SetIndex(eve, i); /* set_inline */
+		BM_elem_index_set(eve, i); /* set_inline */
 
 		normal_float_to_short_v3(mv->no, eve->no);
 
-		mv->flag = BM_Vert_Flag_To_MEFlag(eve);
+		mv->flag = BM_vert_flag_to_mflag(eve);
 
 		if (has_vert_bweight)
-			mv->bweight = (unsigned char)(BM_GetCDf(&bm->vdata, eve, CD_BWEIGHT)*255.0f);
+			mv->bweight = (unsigned char)(BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT)*255.0f);
 
 		if (add_orig) *index = i;
 
@@ -2064,21 +2064,21 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 	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++) {
+	eed = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
+	for (i=0; eed; eed=BM_iter_step(&iter), i++, index++) {
 		MEdge *med = &medge[i];
 
-		BM_SetIndex(eed, i); /* set_inline */
+		BM_elem_index_set(eed, i); /* set_inline */
 
-		med->v1 = BM_GetIndex(eed->v1);
-		med->v2 = BM_GetIndex(eed->v2);
+		med->v1 = BM_elem_index_get(eed->v1);
+		med->v2 = BM_elem_index_get(eed->v2);
 
 		if (has_crease)
-			med->crease = (unsigned char)(BM_GetCDf(&bm->edata, eed, CD_CREASE)*255.0f);
+			med->crease = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_CREASE)*255.0f);
 		if (has_edge_bweight)
-			med->bweight = (unsigned char)(BM_GetCDf(&bm->edata, eed, CD_BWEIGHT)*255.0f);
+			med->bweight = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT)*255.0f);
 		
-		med->flag = BM_Edge_Flag_To_MEFlag(eed);
+		med->flag = BM_edge_flag_to_mflag(eed);
 
 		CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
 		if (add_orig) *index = i;
@@ -2089,7 +2089,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 	if (use_tessface) {
 		int *polyindex;
 
-		BM_ElemIndex_Ensure(bm, BM_FACE);
+		BM_mesh_elem_index_ensure(bm, BM_FACE);
 
 		polyindex = dm->getTessFaceDataArray(dm, CD_POLYINDEX);
 		index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
@@ -2098,15 +2098,15 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 			BMLoop **l = em->looptris[i];
 			efa = l[0]->f;
 
-			mf->v1 = BM_GetIndex(l[0]->v);
-			mf->v2 = BM_GetIndex(l[1]->v);
-			mf->v3 = BM_GetIndex(l[2]->v);
+			mf->v1 = BM_elem_index_get(l[0]->v);
+			mf->v2 = BM_elem_index_get(l[1]->v);
+			mf->v3 = BM_elem_index_get(l[2]->v);
 			mf->v4 = 0;
 			mf->mat_nr = efa->mat_nr;
-			mf->flag = BM_Face_Flag_To_MEFlag(efa);
+			mf->flag = BM_face_flag_to_mflag(efa);
 
-			*index = add_orig ? BM_GetIndex(efa) : *(int*)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX);
-			*polyindex = BM_GetIndex(efa);
+			*index = add_orig ? BM_elem_index_get(efa) : *(int*)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX);
+			*polyindex = BM_elem_index_get(efa);
 
 			loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numTex);
 			test_index_face(mf, &dm->faceData, i, 3);
@@ -2115,21 +2115,21 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 	
 	index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
 	j = 0;
-	efa = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL);
-	for (i=0; efa; i++, efa=BMIter_Step(&iter), index++) {
+	efa = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
+	for (i=0; efa; i++, efa=BM_iter_step(&iter), index++) {
 		BMLoop *l;
 		MPoly *mp = &mpoly[i];
 
-		BM_SetIndex(efa, i); /* set_inline */
+		BM_elem_index_set(efa, i); /* set_inline */
 
 		mp->totloop = efa->len;
-		mp->flag = BM_Face_Flag_To_MEFlag(efa);
+		mp->flag = BM_face_flag_to_mflag(efa);
 		mp->loopstart = j;
 		mp->mat_nr = efa->mat_nr;
 		
 		BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
-			mloop->v = BM_GetIndex(l->v);
-			mloop->e = BM_GetIndex(l->e);
+			mloop->v = BM_elem_index_get(l->v);
+			mloop->e = BM_elem_index_get(l->e);
 			CustomData_from_bmesh_block(&bm->ldata, &dm->loopData, l->head.data, j);
 
 			j++;
diff --git a/source/blender/blenkernel/intern/editderivedmesh.c b/source/blender/blenkernel/intern/editderivedmesh.c
index 253d215ac58..a200c3b20e8 100644
--- a/source/blender/blenkernel/intern/editderivedmesh.c
+++ b/source/blender/blenkernel/intern/editderivedmesh.c
@@ -89,7 +89,7 @@ BMEditMesh *BMEdit_Copy(BMEditMesh *tm)
 
 	tm2->derivedCage = tm2->derivedFinal = NULL;
 
-	tm2->bm = BM_Copy_Mesh(tm->bm);
+	tm2->bm = BM_mesh_copy(tm->bm);
 
 	/*The tesselation is NOT calculated on the copy here,
 	  because currently all the callers of this function use
@@ -149,8 +149,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm)
 
 #endif
 
-	f = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL);
-	for ( ; f; f=BMIter_Step(&iter)) {
+	f = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
+	for ( ; f; f=BM_iter_step(&iter)) {
 		/*don't consider two-edged faces*/
 		if (f->len < 3) {
 			/* do nothing */
@@ -162,8 +162,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm)
 
 		else if (f->len == 3) {
 			BLI_array_growone(looptris);
-			l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
-			for (j=0; l; l=BMIter_Step(&liter), j++) {
+			l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
+			for (j=0; l; l=BM_iter_step(&liter), j++) {
 				looptris[i][j] = l;
 			}
 			i += 1;
@@ -172,8 +172,8 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm)
 			BMLoop *ltmp[4];
 			BLI_array_growitems(looptris, 2);
 
-			l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
-			for (j=0; l; l=BMIter_Step(&liter), j++) {
+			l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
+			for (j=0; l; l=BM_iter_step(&liter), j++) {
 				ltmp[j] = l;
 			}
 
@@ -198,10 +198,10 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm)
 
 			BLI_begin_edgefill();
 			/*scanfill time*/
-			l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
-			for (j=0; l; l=BMIter_Step(&liter), j++) {
+			l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
+			for (j=0; l; l=BM_iter_step(&liter), j++) {
 				/*mark order*/
-				BM_SetIndex(l, j); /* set_loop */
+				BM_elem_index_set(l, j); /* set_loop */
 
 				v = BLI_addfillvert(l->v->co);
 				v->tmp.p = l;
@@ -225,9 +225,9 @@ static void BMEdit_RecalcTesselation_intern(BMEditMesh *tm)
 				BMLoop *l2= efa->v2->tmp.p;
 				BMLoop *l3= efa->v3->tmp.p;
 
-				if (BM_GetIndex(l1) > BM_GetIndex(l2)) { SWAP(BMLoop*, l1, l2); }
-				if (BM_GetIndex(l2) > BM_GetIndex(l3)) { SWAP(BMLoop*, l2, l3); }
-				if (BM_GetIndex(l1) > BM_GetIndex(l2)) { SWAP(BMLoop*, l1, l2); }
+				if (BM_elem_index_get(l1) > BM_elem_index_get(l2)) { SWAP(BMLoop*, l1, l2); }
+				if (BM_elem_index_get(l2) > BM_elem_index_get(l3)) { SWAP(BMLoop*, l2, l3); }
+				if (BM_elem_index_get(l1) > BM_elem_index_get(l2)) { SWAP(BMLoop*, l1, l2); }
 
 				looptris[i][0] = l1;
 				looptris[i][1] = l2;
@@ -308,7 +308,7 @@ void BMEdit_Free(BMEditMesh *em)
 	if (em->face_index) MEM_freeN(em->face_index);
 
 	if (em->bm)
-		BM_Free_Mesh(em->bm);
+		BM_mesh_free(em->bm);
 }
 
 /*
@@ -384,10 +384,10 @@ static void UNUSED_FUNCTION(bmdm_recalc_lookups)(EditDerivedBMesh *bmdm)
 		BMHeader **table = iters_table[a];
 		BMHeader *ele;
 
-		ele = BMIter_New(&iter, bmdm->tc->bm, iter_types[a], NULL);
-		for (i=0; ele; ele=BMIter_Step(&iter), i++) {
+		ele = BM_iter_new(&iter, bmdm->tc->bm, iter_types[a], NULL);
+		for (i=0; ele; ele=BM_iter_step(&iter), i++) {
 			table[i] = ele;
-			BM_SetIndex(ele, i);  /* set_ok */
+			BM_elem_index_set(ele, i);  /* set_ok */
 		}
 	}
 	bmdm->tc->bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE);
@@ -417,8 +417,8 @@ static void emDM_foreachMappedVert(
 	BMIter iter;
 	int i;
 
-	eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-	for (i=0; eve; i++, eve=BMIter_Step(&iter)) {
+	eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
+	for (i=0; eve; i++, eve=BM_iter_step(&iter)) {
 		if (bmdm->vertexCos) {
 			func(userData, i, bmdm->vertexCos[i], bmdm->vertexNos[i], NULL);
 		}
@@ -439,17 +439,17 @@ static void emDM_foreachMappedEdge(
 
 	if (bmdm->vertexCos) {
 
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
+		BM_mesh_elem_index_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))
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter))
 			func(userData, i,
-				 bmdm->vertexCos[BM_GetIndex(eed->v1)],
-				 bmdm->vertexCos[BM_GetIndex(eed->v2)]);
+				 bmdm->vertexCos[BM_elem_index_get(eed->v1)],
+				 bmdm->vertexCos[BM_elem_index_get(eed->v2)]);
 	}
 	else {
-		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
-		for (i=0; eed; i++,eed=BMIter_Step(&iter))
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter))
 			func(userData, i, eed->v1->co, eed->v2->co);
 	}
 }
@@ -466,22 +466,22 @@ static void emDM_drawMappedEdges(
 
 	if (bmdm->vertexCos) {
 
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
+		BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT);
 
 		glBegin(GL_LINES);
-		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
-		for (i=0; eed; i++,eed=BMIter_Step(&iter)) {
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter)) {
 			if (!setDrawOptions || setDrawOptions(userData, i)) {
-				glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v1)]);
-				glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v2)]);
+				glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]);
+				glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v2)]);
 			}
 		}
 		glEnd();
 	}
 	else {
 		glBegin(GL_LINES);
-		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
-		for (i=0; eed; i++,eed=BMIter_Step(&iter)) {
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter)) {
 			if (!setDrawOptions || setDrawOptions(userData, i)) {
 				glVertex3fv(eed->v1->co);
 				glVertex3fv(eed->v2->co);
@@ -511,24 +511,24 @@ static void emDM_drawMappedEdgesInterp(
 
 	if (bmdm->vertexCos) {
 
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
+		BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT);
 
 		glBegin(GL_LINES);
-		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
-		for (i=0; eed; i++,eed=BMIter_Step(&iter)) {
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter)) {
 			if (!setDrawOptions || setDrawOptions(userData, i)) {
 				setDrawInterpOptions(userData, i, 0.0);
-				glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v1)]);
+				glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]);
 				setDrawInterpOptions(userData, i, 1.0);
-				glVertex3fv(bmdm->vertexCos[BM_GetIndex(eed->v2)]);
+				glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v2)]);
 			}
 		}
 		glEnd();
 	}
 	else {
 		glBegin(GL_LINES);
-		eed = BMIter_New(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
-		for (i=0; eed; i++,eed=BMIter_Step(&iter)) {
+		eed = BM_iter_new(&iter, bmdm->tc->bm, BM_EDGES_OF_MESH, NULL);
+		for (i=0; eed; i++,eed=BM_iter_step(&iter)) {
 			if (!setDrawOptions || setDrawOptions(userData, i)) {
 				setDrawInterpOptions(userData, i, 0.0);
 				glVertex3fv(eed->v1->co);
@@ -553,7 +553,7 @@ static void emDM_drawUVEdges(DerivedMesh *dm)
 		BMLoop *l;
 		MLoopUV *lastluv = NULL, *firstluv = NULL;
 
-		if (BM_TestHFlag(efa, BM_ELEM_HIDDEN))
+		if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
 			continue;
 
 		BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
@@ -589,15 +589,15 @@ static void emDM__calcFaceCent(BMesh *bm, BMFace *efa, float cent[3], float (*ve
 	/*simple (and stupid) median (average) based method :/ */
 
 	if (vertexCos) {
-		l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, efa);
-		for (; l; l=BMIter_Step(&iter)) {
-			add_v3_v3(cent, vertexCos[BM_GetIndex(l->v)]);
+		l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, efa);
+		for (; l; l=BM_iter_step(&iter)) {
+			add_v3_v3(cent, vertexCos[BM_elem_index_get(l->v)]);
 			tot++;
 		}
 	}
 	else {
-		l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, efa);
-		for (; l; l=BMIter_Step(&iter)) {
+		l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, efa);
+		for (; l; l=BM_iter_step(&iter)) {
 			add_v3_v3(cent, l->v->co);
 			tot++;
 		}
@@ -621,14 +621,14 @@ static void emDM_foreachMappedFaceCenter(
 
 	/* ensure for face center calculation */
 	if (bmdm->vertexCos) {
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT);
+		BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT);
 		polyNos = bmdm->polyNos;
 
 		BLI_assert(polyNos != NULL);
 	}
 
-	efa = BMIter_New(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL);
-	for (i=0; efa; efa=BMIter_Step(&iter), i++) {
+	efa = BM_iter_new(&iter, bmdm->tc->bm, BM_FACES_OF_MESH, NULL);
+	for (i=0; efa; efa=BM_iter_step(&iter), i++) {
 		emDM__calcFaceCent(bmdm->tc->bm, efa, cent, bmdm->vertexCos);
 		func(userData, i, cent, polyNos ? polyNos[i] : efa->no);
 	}
@@ -665,16 +665,16 @@ static void emDM_drawMappedFaces(
 		float (*polyNos)[3]=   bmdm->polyNos;
 		// int *triPolyMap= bmdm->triPolyMap;
 
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT | BM_FACE);
+		BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_VERT | BM_FACE);
 
 		for (i=0; i < tottri; i++) {
 			BMLoop **l = looptris[i];
 			int drawSmooth;
 
 			efa = l[0]->f;
-			drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH);
+			drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
 
-			draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth);
+			draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_elem_index_get(efa), &drawSmooth);
 			if (draw) {
 				const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */
 				if (draw==2) { /* enabled with stipple */
@@ -691,9 +691,9 @@ static void emDM_drawMappedFaces(
 						if (poly_prev != GL_ZERO) glEnd();
 						glBegin((poly_prev= poly_type)); /* BMesh: will always be GL_TRIANGLES */
 					}
-					glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]);
 				}
 				else {
 					const GLenum shade_type= drawSmooth ? GL_SMOOTH : GL_FLAT;
@@ -708,18 +708,18 @@ static void emDM_drawMappedFaces(
 					}
 
 					if (!drawSmooth) {
-						glNormal3fv(polyNos[BM_GetIndex(efa)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]);
+						glNormal3fv(polyNos[BM_elem_index_get(efa)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]);
 					}
 					else {
-						glNormal3fv(vertexNos[BM_GetIndex(l[0]->v)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[0]->v)]);
-						glNormal3fv(vertexNos[BM_GetIndex(l[1]->v)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[1]->v)]);
-						glNormal3fv(vertexNos[BM_GetIndex(l[2]->v)]);
-						glVertex3fv(vertexCos[BM_GetIndex(l[2]->v)]);
+						glNormal3fv(vertexNos[BM_elem_index_get(l[0]->v)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[0]->v)]);
+						glNormal3fv(vertexNos[BM_elem_index_get(l[1]->v)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[1]->v)]);
+						glNormal3fv(vertexNos[BM_elem_index_get(l[2]->v)]);
+						glVertex3fv(vertexCos[BM_elem_index_get(l[2]->v)]);
 					}
 				}
 
@@ -737,16 +737,16 @@ static void emDM_drawMappedFaces(
 		}
 	}
 	else {
-		BM_ElemIndex_Ensure(bmdm->tc->bm, BM_FACE);
+		BM_mesh_elem_index_ensure(bmdm->tc->bm, BM_FACE);
 
 		for (i=0; i < tottri; i++) {
 			BMLoop **l = looptris[i];
 			int drawSmooth;
 
 			efa = l[0]->f;
-			drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH);
+			drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
 
-			draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth);
+			draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_elem_index_get(efa), &drawSmooth);
 			if (draw) {
 				const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */
 				if (draw==2) { /* enabled with stipple */
@@ -860,10 +860,10 @@ static void emDM_drawFacesTex_common(
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
 
-	BM_ElemIndex_Ensure(bm, BM_FACE);
+	BM_mesh_elem_index_ensure(bm, BM_FACE);
 
 	if (vertexCos) {
-		BM_ElemIndex_Ensure(bm, BM_VERT);
+		BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 		glBegin(GL_TRIANGLES);
 		for (i=0; i<em->tottri; i++) {
@@ -871,7 +871,7 @@ static void emDM_drawFacesTex_common(
 			MTexPoly *tp= CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY);
 			MTFace mtf = {{{0}}};
 			/*unsigned char *cp= NULL;*/ /*UNUSED*/
-			int drawSmooth= BM_TestHFlag(ls[0]->f, BM_ELEM_SMOOTH);
+			int drawSmooth= BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH);
 			int flag;
 
 			efa = ls[0]->f;
@@ -883,7 +883,7 @@ static void emDM_drawFacesTex_common(
 			if (drawParams)
 				flag= drawParams(&mtf, has_vcol, efa->mat_nr);
 			else if (drawParamsMapped)
-				flag= drawParamsMapped(userData, BM_GetIndex(efa));
+				flag= drawParamsMapped(userData, BM_elem_index_get(efa));
 			else
 				flag= 1;
 
@@ -895,53 +895,53 @@ static void emDM_drawFacesTex_common(
 				}
 
 				if (!drawSmooth) {
-					glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]);
+					glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]);
 
 					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
 
 					glTexCoord2fv(luv[0]->uv);
 					glColor3ub(lcol[0]->b, lcol[0]->g, lcol[0]->r);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[0]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[0]->v)]);
 
 					glTexCoord2fv(luv[1]->uv);
 					glColor3ub(lcol[1]->b, lcol[1]->g, lcol[1]->r);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[1]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[1]->v)]);
 
 					glTexCoord2fv(luv[2]->uv);
 					glColor3ub(lcol[2]->b, lcol[2]->g, lcol[2]->r);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[2]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[2]->v)]);
 				}
 				else {
 					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
 
 					glTexCoord2fv(luv[0]->uv);
 					glColor3ub(lcol[0]->b, lcol[0]->g, lcol[0]->r);
-					glNormal3fv(vertexNos[BM_GetIndex(ls[0]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[0]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ls[0]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[0]->v)]);
 
 					glTexCoord2fv(luv[1]->uv);
 					glColor3ub(lcol[1]->b, lcol[1]->g, lcol[1]->r);
-					glNormal3fv(vertexNos[BM_GetIndex(ls[1]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[1]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ls[1]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[1]->v)]);
 
 					glTexCoord2fv(luv[2]->uv);
 					glColor3ub(lcol[2]->b, lcol[2]->g, lcol[2]->r);
-					glNormal3fv(vertexNos[BM_GetIndex(ls[2]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ls[2]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ls[2]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ls[2]->v)]);
 				}
 			}
 		}
 		glEnd();
 	}
 	else {
-		BM_ElemIndex_Ensure(bm, BM_VERT);
+		BM_mesh_elem_index_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);
 			MTFace mtf = {{{0}}};
 			/*unsigned char *cp= NULL;*/ /*UNUSED*/
-			int drawSmooth= BM_TestHFlag(ls[0]->f, BM_ELEM_SMOOTH);
+			int drawSmooth= BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH);
 			int flag;
 
 			efa = ls[0]->f;
@@ -953,7 +953,7 @@ static void emDM_drawFacesTex_common(
 			if (drawParams)
 				flag= drawParams(&mtf, has_vcol, efa->mat_nr);
 			else if (drawParamsMapped)
-				flag= drawParamsMapped(userData, BM_GetIndex(efa));
+				flag= drawParamsMapped(userData, BM_elem_index_get(efa));
 			else
 				flag= 1;
 
@@ -1067,11 +1067,11 @@ static void emDM_drawMappedFacesGLSL(
 
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
-	BM_ElemIndex_Ensure(bm, BM_VERT | BM_FACE);
+	BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
 
 #define PASSATTRIB(loop, eve, vert) {											\
 	if (attribs.totorco) {														\
-		float *orco = attribs.orco.array[BM_GetIndex(eve)];						\
+		float *orco = attribs.orco.array[BM_elem_index_get(eve)];						\
 		glVertexAttrib3fvARB(attribs.orco.glIndex, orco);						\
 	}																			\
 	for (b = 0; b < attribs.tottface; b++) {									\
@@ -1095,9 +1095,9 @@ static void emDM_drawMappedFacesGLSL(
 		int drawSmooth;
 
 		efa = ltri[0]->f;
-		drawSmooth= BM_TestHFlag(efa, BM_ELEM_SMOOTH);
+		drawSmooth= BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
 
-		if (setDrawOptions && !setDrawOptions(userData, BM_GetIndex(efa)))
+		if (setDrawOptions && !setDrawOptions(userData, BM_elem_index_get(efa)))
 			continue;
 
 		new_matnr = efa->mat_nr + 1;
@@ -1110,26 +1110,26 @@ static void emDM_drawMappedFacesGLSL(
 		if (dodraw) {
 			glBegin(GL_TRIANGLES);
 			if (!drawSmooth) {
-				if (vertexCos) glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]);
+				if (vertexCos) glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]);
 				else glNormal3fv(efa->no);
 
 				PASSATTRIB(ltri[0], ltri[0]->v, 0);
-				if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]);
+				if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]);
 				else glVertex3fv(ltri[0]->v->co);
 
 				PASSATTRIB(ltri[1], ltri[1]->v, 1);
-				if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]);
+				if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]);
 				else glVertex3fv(ltri[1]->v->co);
 
 				PASSATTRIB(ltri[2], ltri[2]->v, 2);
-				if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]);
+				if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]);
 				else glVertex3fv(ltri[2]->v->co);
 			}
 			else {
 				PASSATTRIB(ltri[0], ltri[0]->v, 0);
 				if (vertexCos) {
-					glNormal3fv(vertexNos[BM_GetIndex(ltri[0]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ltri[0]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]);
 				}
 				else {
 					glNormal3fv(ltri[0]->v->no);
@@ -1138,8 +1138,8 @@ static void emDM_drawMappedFacesGLSL(
 
 				PASSATTRIB(ltri[1], ltri[1]->v, 1);
 				if (vertexCos) {
-					glNormal3fv(vertexNos[BM_GetIndex(ltri[1]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ltri[1]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]);
 				}
 				else {
 					glNormal3fv(ltri[1]->v->no);
@@ -1148,8 +1148,8 @@ static void emDM_drawMappedFacesGLSL(
 
 				PASSATTRIB(ltri[2], ltri[2]->v, 2);
 				if (vertexCos) {
-					glNormal3fv(vertexNos[BM_GetIndex(ltri[2]->v)]);
-					glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]);
+					glNormal3fv(vertexNos[BM_elem_index_get(ltri[2]->v)]);
+					glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]);
 				}
 				else {
 					glNormal3fv(ltri[2]->v->no);
@@ -1190,11 +1190,11 @@ static void emDM_drawMappedFacesMat(
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
 
-	BM_ElemIndex_Ensure(bm, BM_VERT);
+	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 #define PASSATTRIB(loop, eve, vert) {											\
 	if (attribs.totorco) {														\
-		float *orco = attribs.orco.array[BM_GetIndex(eve)];						\
+		float *orco = attribs.orco.array[BM_elem_index_get(eve)];						\
 		glVertexAttrib3fvARB(attribs.orco.glIndex, orco);						\
 	}																			\
 	for (b = 0; b < attribs.tottface; b++) {									\
@@ -1217,10 +1217,10 @@ static void emDM_drawMappedFacesMat(
 		int drawSmooth;
 
 		efa = ltri[0]->f;
-		drawSmooth = BM_TestHFlag(efa, BM_ELEM_SMOOTH);
+		drawSmooth = BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
 
 		/* face hiding */
-		if (setFace && !setFace(userData, BM_GetIndex(efa)))
+		if (setFace && !setFace(userData, BM_elem_index_get(efa)))
 			continue;
 
 		/* material */
@@ -1233,27 +1233,27 @@ static void emDM_drawMappedFacesMat(
 		/* face */
 		glBegin(GL_TRIANGLES);
 		if (!drawSmooth) {
-			if (vertexCos) glNormal3fv(bmdm->polyNos[BM_GetIndex(efa)]);
+			if (vertexCos) glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]);
 			else glNormal3fv(efa->no);
 
 			PASSATTRIB(ltri[0], ltri[0]->v, 0);
-			if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]);
+			if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]);
 			else glVertex3fv(ltri[0]->v->co);
 
 			PASSATTRIB(ltri[1], ltri[1]->v, 1);
-			if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]);
+			if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]);
 			else glVertex3fv(ltri[1]->v->co);
 
 			PASSATTRIB(ltri[2], ltri[2]->v, 2);
-			if (vertexCos) glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]);
+			if (vertexCos) glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]);
 			else glVertex3fv(ltri[2]->v->co);
 
 		}
 		else {
 			PASSATTRIB(ltri[0], ltri[0]->v, 0);
 			if (vertexCos) {
-				glNormal3fv(vertexNos[BM_GetIndex(ltri[0]->v)]);
-				glVertex3fv(vertexCos[BM_GetIndex(ltri[0]->v)]);
+				glNormal3fv(vertexNos[BM_elem_index_get(ltri[0]->v)]);
+				glVertex3fv(vertexCos[BM_elem_index_get(ltri[0]->v)]);
 			}
 			else {
 				glNormal3fv(ltri[0]->v->no);
@@ -1262,8 +1262,8 @@ static void emDM_drawMappedFacesMat(
 
 			PASSATTRIB(ltri[1], ltri[1]->v, 1);
 			if (vertexCos) {
-				glNormal3fv(vertexNos[BM_GetIndex(ltri[1]->v)]);
-				glVertex3fv(vertexCos[BM_GetIndex(ltri[1]->v)]);
+				glNormal3fv(vertexNos[BM_elem_index_get(ltri[1]->v)]);
+				glVertex3fv(vertexCos[BM_elem_index_get(ltri[1]->v)]);
 			}
 			else {
 				glNormal3fv(ltri[1]->v->no);
@@ -1272,8 +1272,8 @@ static void emDM_drawMappedFacesMat(
 
 			PASSATTRIB(ltri[2], ltri[2]->v, 2);
 			if (vertexCos) {
-				glNormal3fv(vertexNos[BM_GetIndex(ltri[2]->v)]);
-				glVertex3fv(vertexCos[BM_GetIndex(ltri[2]->v)]);
+				glNormal3fv(vertexNos[BM_elem_index_get(ltri[2]->v)]);
+				glVertex3fv(vertexCos[BM_elem_index_get(ltri[2]->v)]);
 			}
 			else {
 				glNormal3fv(ltri[2]->v->no);
@@ -1293,8 +1293,8 @@ static void emDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
 	int i;
 
 	if (bmdm->tc->bm->totvert) {
-		eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++) {
+		eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
+		for (i=0; eve; eve=BM_iter_step(&iter), i++) {
 			if (bmdm->vertexCos) {
 				DO_MINMAX(bmdm->vertexCos[i], min_r, max_r);
 			}
@@ -1348,10 +1348,10 @@ static int bmvert_to_mvert(BMesh *bm, BMVert *ev, MVert *vert_r)
 
 	normal_float_to_short_v3(vert_r->no, ev->no);
 
-	vert_r->flag = BM_Vert_Flag_To_MEFlag(ev);
+	vert_r->flag = BM_vert_flag_to_mflag(ev);
 
 	if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
-		vert_r->bweight = (unsigned char) (BM_GetCDf(&bm->vdata, ev, CD_BWEIGHT)*255.0f);
+		vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, ev, CD_BWEIGHT)*255.0f);
 	}
 
 	return 1;
@@ -1384,17 +1384,17 @@ static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
 	e = bmdm->etable[index];
 
 	if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
-		edge_r->bweight = (unsigned char) (BM_GetCDf(&bm->edata, e, CD_BWEIGHT)*255.0f);
+		edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_BWEIGHT)*255.0f);
 	}
 
 	if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
-		edge_r->crease = (unsigned char) (BM_GetCDf(&bm->edata, e, CD_CREASE)*255.0f);
+		edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_CREASE)*255.0f);
 	}
 
-	edge_r->flag = BM_Edge_Flag_To_MEFlag(e);
+	edge_r->flag = BM_edge_flag_to_mflag(e);
 
-	edge_r->v1 = BM_GetIndex(e->v1);
-	edge_r->v2 = BM_GetIndex(e->v2);
+	edge_r->v1 = BM_elem_index_get(e->v1);
+	edge_r->v2 = BM_elem_index_get(e->v2);
 }
 
 static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r)
@@ -1413,11 +1413,11 @@ static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r)
 	ef = l[0]->f;
 
 	face_r->mat_nr = (unsigned char) ef->mat_nr;
-	face_r->flag = BM_Face_Flag_To_MEFlag(ef);
+	face_r->flag = BM_face_flag_to_mflag(ef);
 
-	face_r->v1 = BM_GetIndex(l[0]->v);
-	face_r->v2 = BM_GetIndex(l[1]->v);
-	face_r->v3 = BM_GetIndex(l[2]->v);
+	face_r->v1 = BM_elem_index_get(l[0]->v);
+	face_r->v2 = BM_elem_index_get(l[1]->v);
+	face_r->v3 = BM_elem_index_get(l[2]->v);
 	face_r->v4 = 0;
 
 	test_index_face(face_r, NULL, 0, 3);
@@ -1429,16 +1429,16 @@ static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
 	BMVert *ev;
 	BMIter iter;
 
-	ev = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
-	for ( ; ev; ev = BMIter_Step(&iter), ++vert_r) {
+	ev = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
+	for ( ; ev; ev = BM_iter_step(&iter), ++vert_r) {
 		copy_v3_v3(vert_r->co, ev->co);
 
 		normal_float_to_short_v3(vert_r->no, ev->no);
 
-		vert_r->flag = BM_Vert_Flag_To_MEFlag(ev);
+		vert_r->flag = BM_vert_flag_to_mflag(ev);
 
 		if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
-			vert_r->bweight = (unsigned char) (BM_GetCDf(&bm->vdata, ev, CD_BWEIGHT)*255.0f);
+			vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, ev, CD_BWEIGHT)*255.0f);
 		}
 	}
 }
@@ -1451,22 +1451,22 @@ static void emDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
 	int has_bweight = CustomData_has_layer(&bm->edata, CD_BWEIGHT);
 	int has_crease = CustomData_has_layer(&bm->edata, CD_CREASE);
 
-	BM_ElemIndex_Ensure(bm, BM_VERT);
+	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
-	ee = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);
-	for ( ; ee; ee=BMIter_Step(&iter), edge_r++) {
+	ee = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
+	for ( ; ee; ee=BM_iter_step(&iter), edge_r++) {
 		if (has_bweight) {
-			edge_r->bweight = (unsigned char) (BM_GetCDf(&bm->edata, ee, CD_BWEIGHT)*255.0f);
+			edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, ee, CD_BWEIGHT)*255.0f);
 		}
 
 		if (has_crease) {
-			edge_r->crease = (unsigned char) (BM_GetCDf(&bm->edata, ee, CD_CREASE)*255.0f);
+			edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, ee, CD_CREASE)*255.0f);
 		}
 
-		edge_r->flag = BM_Edge_Flag_To_MEFlag(ee);
+		edge_r->flag = BM_edge_flag_to_mflag(ee);
 
-		edge_r->v1 = BM_GetIndex(ee->v1);
-		edge_r->v2 = BM_GetIndex(ee->v2);
+		edge_r->v1 = BM_elem_index_get(ee->v1);
+		edge_r->v2 = BM_elem_index_get(ee->v2);
 	}
 }
 
@@ -1478,7 +1478,7 @@ static void emDM_copyTessFaceArray(DerivedMesh *dm, MFace *face_r)
 	BMLoop **l;
 	int i;
 
-	BM_ElemIndex_Ensure(bm, BM_VERT);
+	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 	for (i=0; i<bmdm->tc->tottri; i++, face_r++) {
 		l = bmdm->tc->looptris[i];
@@ -1486,11 +1486,11 @@ static void emDM_copyTessFaceArray(DerivedMesh *dm, MFace *face_r)
 
 		face_r->mat_nr = (unsigned char) ef->mat_nr;
 
-		face_r->flag = BM_Face_Flag_To_MEFlag(ef);
+		face_r->flag = BM_face_flag_to_mflag(ef);
 
-		face_r->v1 = BM_GetIndex(l[0]->v);
-		face_r->v2 = BM_GetIndex(l[1]->v);
-		face_r->v3 = BM_GetIndex(l[2]->v);
+		face_r->v1 = BM_elem_index_get(l[0]->v);
+		face_r->v2 = BM_elem_index_get(l[1]->v);
+		face_r->v3 = BM_elem_index_get(l[2]->v);
 		face_r->v4 = 0;
 
 		test_index_face(face_r, NULL, 0, 3);
@@ -1506,12 +1506,12 @@ static void emDM_copyLoopArray(DerivedMesh *dm, MLoop *loop_r)
 	BMFace *f;
 	BMLoop *l;
 
-	BM_ElemIndex_Ensure(bm, BM_VERT | BM_EDGE);
+	BM_mesh_elem_index_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) {
-			loop_r->v = BM_GetIndex(l->v);
-			loop_r->e = BM_GetIndex(l->e);
+			loop_r->v = BM_elem_index_get(l->v);
+			loop_r->e = BM_elem_index_get(l->e);
 			loop_r++;
 		}
 	}
@@ -1527,7 +1527,7 @@ static void emDM_copyPolyArray(DerivedMesh *dm, MPoly *poly_r)
 
 	i = 0;
 	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
-		poly_r->flag = BM_Face_Flag_To_MEFlag(f);
+		poly_r->flag = BM_face_flag_to_mflag(f);
 		poly_r->loopstart = i;
 		poly_r->totloop = f->len;
 		poly_r->mat_nr = f->mat_nr;
@@ -1722,8 +1722,8 @@ DerivedMesh *getEditDerivedBMesh(
 
 		DM_add_vert_layer(&bmdm->dm, CD_MDEFORMVERT, CD_CALLOC, NULL);
 
-		eve = BMIter_New(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&iter), i++)
+		eve = BM_iter_new(&iter, bmdm->tc->bm, BM_VERTS_OF_MESH, NULL);
+		for (i=0; eve; eve=BM_iter_step(&iter), i++)
 			DM_set_vert_data(&bmdm->dm, i, CD_MDEFORMVERT,
 							 CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_MDEFORMVERT));
 	}
@@ -1735,24 +1735,24 @@ DerivedMesh *getEditDerivedBMesh(
 		BMIter viter;
 		int i;
 
-		BM_ElemIndex_Ensure(bm, BM_VERT);
+		BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 		bmdm->vertexNos = MEM_callocN(sizeof(*bmdm->vertexNos) * bm->totvert, "bmdm_vno");
 		bmdm->polyNos = MEM_mallocN(sizeof(*bmdm->polyNos)*bm->totface, "bmdm_pno");
 
 		i = 0;
 		BM_ITER(efa, &fiter, bm, BM_FACES_OF_MESH, NULL) {
-			BM_SetIndex(efa, i); /* set_inline */
-			BM_Face_UpdateNormal_VertexCos(bm, efa, bmdm->polyNos[i], vertexCos);
+			BM_elem_index_set(efa, i); /* set_inline */
+			BM_face_normal_update_vcos(bm, efa, bmdm->polyNos[i], vertexCos);
 			i++;
 		}
 		bm->elem_index_dirty &= ~BM_FACE;
 
-		eve=BMIter_New(&viter, bm, BM_VERTS_OF_MESH, NULL);
-		for (i=0; eve; eve=BMIter_Step(&viter), i++) {
+		eve=BM_iter_new(&viter, bm, BM_VERTS_OF_MESH, NULL);
+		for (i=0; eve; eve=BM_iter_step(&viter), i++) {
 			float *no = bmdm->vertexNos[i];
 			BM_ITER(efa, &fiter, bm, BM_FACES_OF_VERT, eve) {
-				add_v3_v3(no, bmdm->polyNos[BM_GetIndex(efa)]);
+				add_v3_v3(no, bmdm->polyNos[BM_elem_index_get(efa)]);
 			}
 
 			/* following Mesh convention; we use vertex coordinate itself
diff --git a/source/blender/blenkernel/intern/key.c b/source/blender/blenkernel/intern/key.c
index 2f05d14bdd5..84af6200f94 100644
--- a/source/blender/blenkernel/intern/key.c
+++ b/source/blender/blenkernel/intern/key.c
@@ -1082,8 +1082,8 @@ static float *get_weights_array(Object *ob, char *vgroup)
 		weights= MEM_callocN(totvert*sizeof(float), "weights");
 
 		if(em) {
-			eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-			for (i=0; eve; eve=BMIter_Step(&iter), i++) {
+			eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
+			for (i=0; eve; eve=BM_iter_step(&iter), i++) {
 				dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
 
 				if(dvert) {
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index a0419ee6343..b907fd1cbae 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -528,9 +528,9 @@ BMesh *BKE_mesh_to_bmesh(Mesh *me, Object *ob)
 	BMesh *bm;
 	int allocsize[4] = {512,512,2048,512};
 
-	bm = BM_Make_Mesh(ob, allocsize);
+	bm = BM_mesh_create(ob, allocsize);
 
-	BMO_CallOpf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", me, ob, 1);
+	BMO_op_callf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", me, ob, 1);
 
 	return bm;
 }
diff --git a/source/blender/blenkernel/intern/modifiers_bmesh.c b/source/blender/blenkernel/intern/modifiers_bmesh.c
index e46d8dd8bce..466b493098d 100644
--- a/source/blender/blenkernel/intern/modifiers_bmesh.c
+++ b/source/blender/blenkernel/intern/modifiers_bmesh.c
@@ -61,7 +61,7 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 	int i, j, k, totvert, totedge, totface;
 	
 	if (em) bm = em->bm;
-	else bm = BM_Make_Mesh(ob, allocsize);
+	else bm = BM_mesh_create(ob, allocsize);
 
 	bmold = *bm;
 
@@ -81,9 +81,9 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 	/*do verts*/
 	mv = mvert = dm->dupVertArray(dm);
 	for (i = 0; i < totvert; i++, mv++) {
-		v = BM_Make_Vert(bm, mv->co, NULL);
+		v = BM_vert_create(bm, mv->co, NULL);
 		normal_short_to_float_v3(v->no, mv->no);
-		v->head.hflag = BM_Vert_Flag_From_MEFlag(mv->flag);
+		v->head.hflag = BM_vert_flag_from_mflag(mv->flag);
 
 		CustomData_to_bmesh_block(&dm->vertData, &bm->vdata, i, &v->head.data);
 		vtable[i] = v;
@@ -93,9 +93,9 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 	/*do edges*/
 	me = medge = dm->dupEdgeArray(dm);
 	for (i = 0; i < totedge; i++, me++) {
-		e = BM_Make_Edge(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE);
+		e = BM_edge_create(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE);
 
-		e->head.hflag = BM_Edge_Flag_From_MEFlag(me->flag);
+		e->head.hflag = BM_edge_flag_from_mflag(me->flag);
 
 		CustomData_to_bmesh_block(&dm->edgeData, &bm->edata, i, &e->head.data);
 		etable[i] = e;
@@ -121,18 +121,18 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 			edges[j] = etable[ml->e];
 		}
 
-		f = BM_Make_Ngon(bm, verts[0], verts[1], edges, mp->totloop, FALSE);
+		f = BM_face_create_ngon(bm, verts[0], verts[1], edges, mp->totloop, FALSE);
 
 		if (!f)
 			continue;
 
-		f->head.hflag = BM_Face_Flag_From_MEFlag(mp->flag);
+		f->head.hflag = BM_face_flag_from_mflag(mp->flag);
 		f->mat_nr = mp->mat_nr;
 
-		l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
+		l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
 		k = mp->loopstart;
 
-		for (j = 0; l; l = BMIter_Step(&liter), k++) {
+		for (j = 0; l; l = BM_iter_step(&liter), k++) {
 			CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data);
 		}