bmesh:

- moved mesh conversion functions into their own file.

bmesh py api:
- can now create a new empty bmesh without first creating mesh data.
- added function to copy bmesh data back to a mesh.
- bmesh.from_mesh() can now get a mesh which isnt in editmode.

8 files changed, 1036 insertions, 846 deletions

diff --git a/source/blender/bmesh/CMakeLists.txt b/source/blender/bmesh/CMakeLists.txt
index 446a6418431..b9a63f439f1 100644
--- a/source/blender/bmesh/CMakeLists.txt
+++ b/source/blender/bmesh/CMakeLists.txt
@@ -65,6 +65,8 @@ set(SRC
 	intern/bmesh_marking.h
 	intern/bmesh_mesh.c
 	intern/bmesh_mesh.h
+	intern/bmesh_mesh_conv.c
+	intern/bmesh_mesh_conv.h	
 	intern/bmesh_mods.c
 	intern/bmesh_mods.h
 	intern/bmesh_opdefines.c
diff --git a/source/blender/bmesh/bmesh.h b/source/blender/bmesh/bmesh.h
index 9cf71e66b1c..7f9982c07cf 100644
--- a/source/blender/bmesh/bmesh.h
+++ b/source/blender/bmesh/bmesh.h
@@ -286,6 +286,7 @@ BM_INLINE void _bm_elem_index_set(BMHeader *ele, const int index);
 #include "intern/bmesh_iterators.h"
 #include "intern/bmesh_marking.h"
 #include "intern/bmesh_mesh.h"
+#include "intern/bmesh_mesh_conv.h"
 #include "intern/bmesh_mods.h"
 #include "intern/bmesh_operators.h"
 #include "intern/bmesh_polygon.h"
diff --git a/source/blender/bmesh/intern/bmesh_mesh_conv.c b/source/blender/bmesh/intern/bmesh_mesh_conv.c
new file mode 100644
index 00000000000..7b0a59d2ca1
--- /dev/null
+++ b/source/blender/bmesh/intern/bmesh_mesh_conv.c
@@ -0,0 +1,901 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Geoffrey Bantle.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/bmesh/intern/bmesh_mesh_conv.c
+ *  \ingroup bmesh
+ *
+ * BM mesh conversion functions.
+ */
+
+
+#include "bmesh.h"
+#include "intern/bmesh_private.h" /* for element checking */
+
+#include "DNA_mesh_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_object_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_key_types.h"
+
+#include "BLI_listbase.h"
+#include "BLI_array.h"
+#include "BLI_math_vector.h"
+
+#include "BKE_mesh.h"
+#include "BKE_customdata.h"
+
+#include "BKE_global.h" /* ugh - for looping over all objects */
+#include "BKE_main.h"
+
+#include "MEM_guardedalloc.h"
+
+/* Mesh -> BMesh */
+void BM_mesh_to_bmesh(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
+{
+	MVert *mvert;
+	BLI_array_declare(verts);
+	MEdge *medge;
+	MLoop *ml;
+	MPoly *mpoly;
+	KeyBlock *actkey, *block;
+	BMVert *v, **vt = NULL, **verts = NULL;
+	BMEdge *e, **fedges = NULL, **et = NULL;
+	BMFace *f;
+	BMLoop *l;
+	BLI_array_declare(fedges);
+	float (*keyco)[3] = NULL;
+	int *keyi;
+	int totuv, i, j;
+
+	if (!me || !me->totvert) {
+		return; /* sanity check */
+	}
+
+	vt = MEM_mallocN(sizeof(void **) * me->totvert, "mesh to bmesh vtable");
+
+	CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
+	CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
+	CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
+	CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
+
+	/* make sure uv layer names are consisten */
+	totuv = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
+	for (i = 0; i < totuv; i++) {
+		int li = CustomData_get_layer_index_n(&bm->pdata, CD_MTEXPOLY, i);
+		CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
+	}
+
+	if (!CustomData_has_layer(&bm->edata, CD_CREASE))
+		CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
+
+	if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
+		CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
+
+	if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
+		CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
+
+	if ((act_key_nr != 0) && (me->key != NULL)) {
+		actkey = BLI_findlink(&me->key->block, act_key_nr - 1);
+	}
+	else {
+		actkey = NULL;
+	}
+
+	if (actkey && actkey->totelem == me->totvert) {
+		CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
+
+		/* check if we need to generate unique ids for the shapekeys.
+		 * this also exists in the file reading code, but is here for
+		 * a sanity check */
+		if (!me->key->uidgen) {
+			fprintf(stderr,
+			        "%s had to generate shape key uid's in a situation we shouldn't need to! "
+			        "(bmesh internal error)\n",
+			        __func__);
+
+			me->key->uidgen = 1;
+			for (block = me->key->block.first; block; block = block->next) {
+				block->uid = me->key->uidgen++;
+			}
+		}
+
+		keyco = actkey->data;
+		bm->shapenr = act_key_nr;
+		for (i = 0, block = me->key->block.first; block; block = block->next, i++) {
+			CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
+			                           CD_ASSIGN, NULL, 0, block->name);
+
+			j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
+			bm->vdata.layers[j].uid = block->uid;
+		}
+	}
+	else if (actkey) {
+		printf("shapekey <-> mesh mismatch!\n");
+	}
+
+	CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
+	CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
+	CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
+	CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
+
+	for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
+		v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
+		BM_elem_index_set(v, i); /* set_ok */
+		vt[i] = v;
+
+		/* transfer flag */
+		v->head.hflag = BM_vert_flag_from_mflag(mvert->flag);
+
+		/* this is necessary for selection counts to work properly */
+		if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+			BM_vert_select_set(bm, v, TRUE);
+		}
+
+		normal_short_to_float_v3(v->no, mvert->no);
+
+		BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
+
+		/* Copy Custom Dat */
+		CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
+
+		/* set shapekey data */
+		if (me->key) {
+			/* set shape key original index */
+			keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
+			if (keyi) {
+				*keyi = i;
+			}
+
+			for (block = me->key->block.first, j = 0; block; block = block->next, j++) {
+				float *co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, j);
+
+				if (co) {
+					copy_v3_v3(co, ((float *)block->data) + 3 * i);
+				}
+			}
+		}
+	}
+
+	bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
+
+	if (!me->totedge) {
+		MEM_freeN(vt);
+		return;
+	}
+
+	et = MEM_mallocN(sizeof(void **) * me->totedge, "mesh to bmesh etable");
+
+	medge = me->medge;
+	for (i = 0; i < me->totedge; i++, medge++) {
+		e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
+		BM_elem_index_set(e, i); /* set_ok */
+		et[i] = e;
+
+		/* transfer flags */
+		e->head.hflag = BM_edge_flag_from_mflag(medge->flag);
+
+		/* this is necessary for selection counts to work properly */
+		if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE);
+
+		/* Copy Custom Data */
+		CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
+
+		BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
+		BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
+	}
+
+	bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
+
+	mpoly = me->mpoly;
+	for (i = 0; i < me->totpoly; i++, mpoly++) {
+		BMIter iter;
+
+		BLI_array_empty(fedges);
+		BLI_array_empty(verts);
+
+		BLI_array_growitems(fedges, mpoly->totloop);
+		BLI_array_growitems(verts, mpoly->totloop);
+
+		for (j = 0; j < mpoly->totloop; j++) {
+			ml = &me->mloop[mpoly->loopstart + j];
+			v = vt[ml->v];
+			e = et[ml->e];
+
+			fedges[j] = e;
+			verts[j] = v;
+		}
+
+		/* not sure what this block is supposed to do,
+		 * but its unused. so commenting - campbell */
+#if 0
+		{
+			BMVert *v1, *v2;
+			v1 = vt[me->mloop[mpoly->loopstart].v];
+			v2 = vt[me->mloop[mpoly->loopstart + 1].v];
+
+			if (v1 == fedges[0]->v1) {
+				v2 = fedges[0]->v2;
+			}
+			else {
+				v1 = fedges[0]->v2;
+				v2 = fedges[0]->v1;
+			}
+		}
+#endif
+
+		f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
+
+		if (!f) {
+			printf("%s: Warning! Bad face in mesh"
+			       " \"%s\" at index %d!, skipping\n",
+			       __func__, me->id.name + 2, i);
+			continue;
+		}
+
+		/* dont use 'i' since we may have skipped the face */
+		BM_elem_index_set(f, bm->totface - 1); /* set_ok */
+
+		/* transfer flag */
+		f->head.hflag = BM_face_flag_from_mflag(mpoly->flag);
+
+		/* this is necessary for selection counts to work properly */
+		if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE);
+
+		f->mat_nr = mpoly->mat_nr;
+		if (i == me->act_face) bm->act_face = f;
+
+		j = 0;
+		BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
+			/* Save index of correspsonding MLoop */
+			BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
+		}
+
+		/* Copy Custom Data */
+		CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
+	}
+
+	bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
+
+	{
+		BMIter fiter;
+		BMIter liter;
+
+		/* Copy over loop CustomData. Doing this in a separate loop isn't necessary
+		 * but is an optimization, to avoid copying a bunch of interpolated customdata
+		 * for each BMLoop (from previous BMLoops using the same edge), always followed
+		 * by freeing the interpolated data and overwriting it with data from the Mesh. */
+		BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+				int li = BM_elem_index_get(l);
+				CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
+				BM_elem_index_set(l, 0); /* set_loop */
+			}
+		}
+	}
+
+	if (me->mselect && me->totselect != 0) {
+		BMIter iter;
+		BMVert *vertex;
+		BMEdge *edge;
+		BMFace *face;
+		BMVert **vertex_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
+		                                    "Selection Conversion Vertex Pointer Array");
+		BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
+		                                  "Selection Conversion Edge Pointer Array");
+		BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
+		                                  "Selection Conversion Face Pointer Array");
+
+		for (i = 0, vertex = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
+		     vertex;
+		     i++, vertex = BM_iter_step(&iter))
+		{
+			vertex_array[i] = vertex;
+		}
+
+		for (i = 0, edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
+		     edge;
+		     i++, edge = BM_iter_step(&iter))
+		{
+			edge_array[i] = edge;
+		}
+
+		for (i = 0, face = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
+		     face;
+		     i++, face = BM_iter_step(&iter))
+		{
+			face_array[i] = face;
+		}
+
+		if (me->mselect) {
+			for (i = 0; i < me->totselect; i++) {
+				if (me->mselect[i].type == ME_VSEL) {
+					BM_select_history_store(bm, (BMElem *)vertex_array[me->mselect[i].index]);
+				}
+				else if (me->mselect[i].type == ME_ESEL) {
+					BM_select_history_store(bm, (BMElem *)edge_array[me->mselect[i].index]);
+				}
+				else if (me->mselect[i].type == ME_FSEL) {
+					BM_select_history_store(bm, (BMElem *)face_array[me->mselect[i].index]);
+				}
+			}
+		}
+		else {
+			me->totselect = 0;
+		}
+
+		MEM_freeN(vertex_array);
+		MEM_freeN(edge_array);
+		MEM_freeN(face_array);
+	}
+	else {
+		me->totselect = 0;
+		if (me->mselect) {
+			MEM_freeN(me->mselect);
+			me->mselect = NULL;
+		}
+	}
+
+	BLI_array_free(fedges);
+	BLI_array_free(verts);
+
+	MEM_freeN(vt);
+	MEM_freeN(et);
+}
+
+
+/* BMesh -> Mesh */
+static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
+{
+	BMVert **vertMap = NULL;
+	BMVert *eve;
+	int index;
+	int i = 0;
+	BMIter iter;
+
+	/* caller needs to ensure this */
+	BLI_assert(ototvert > 0);
+
+	vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
+	if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
+		int *keyi;
+		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
+			if (keyi) {
+				if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
+					vertMap[index] = eve;
+				}
+			}
+			else {
+				if (i < ototvert) {
+					vertMap[i] = eve;
+				}
+			}
+			i++;
+		}
+	}
+	else {
+		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			if (i < ototvert) {
+				vertMap[i] = eve;
+			}
+			else {
+				break;
+			}
+			i++;
+		}
+	}
+
+	return vertMap;
+}
+
+BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
+{
+	/* this is a cheap way to set the edge draw, its not precise and will
+	 * pick the first 2 faces an edge uses */
+
+
+	if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
+	     (e->l && (e->l != e->l->radial_next)) &&
+	     (dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.998f))
+	{
+		med->flag &= ~ME_EDGEDRAW;
+	}
+}
+
+void BM_mesh_from_bmesh(BMesh *bm, Mesh *me, int dotess)
+{
+	MLoop *mloop;
+	MPoly *mpoly;
+	MVert *mvert, *oldverts;
+	MEdge *med, *medge;
+	BMVert *v, *eve;
+	BMEdge *e;
+	BMLoop *l;
+	BMFace *f;
+	BMIter iter, liter;
+	int i, j, *keyi, ototvert, totloop;
+
+	ototvert = me->totvert;
+
+	/* new Vertex block */
+	if (bm->totvert == 0) mvert = NULL;
+	else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
+
+	/* new Edge block */
+	if (bm->totedge == 0) medge = NULL;
+	else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
+
+	/* build ngon data */
+	/* new Ngon Face block */
+	if (bm->totface == 0) mpoly = NULL;
+	else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
+
+	/* find number of loops to allocate */
+	totloop = 0;
+	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		totloop += f->len;
+	}
+
+	if (totloop == 0) mloop = NULL;
+	else mloop = MEM_callocN(totloop * sizeof(MLoop), "loadeditbMesh loop");
+
+	/* lets save the old verts just in case we are actually working on
+	 * a key ... we now do processing of the keys at the end */
+	oldverts = me->mvert;
+
+	/* don't free this yet */
+	CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
+
+	/* free custom data */
+	CustomData_free(&me->vdata, me->totvert);
+	CustomData_free(&me->edata, me->totedge);
+	CustomData_free(&me->fdata, me->totface);
+	CustomData_free(&me->ldata, me->totloop);
+	CustomData_free(&me->pdata, me->totpoly);
+
+	/* add new custom data */
+	me->totvert = bm->totvert;
+	me->totedge = bm->totedge;
+	me->totloop = totloop;
+	me->totpoly = bm->totface;
+	/* will be overwritten with a valid value if 'dotess' is set, otherwise we
+	 * end up with 'me->totface' and me->mface == NULL which can crash [#28625]
+	 */
+	me->totface = 0;
+
+	CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
+	CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
+	CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
+	CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
+
+	CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
+	CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
+	CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
+	CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
+
+	/* this is called again, 'dotess' arg is used there */
+	mesh_update_customdata_pointers(me, 0);
+
+	i = 0;
+	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+		float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
+
+		mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
+
+		copy_v3_v3(mvert->co, v->co);
+		normal_float_to_short_v3(mvert->no, v->no);
+
+		mvert->flag = BM_vert_flag_to_mflag(v);
+
+		BM_elem_index_set(v, i); /* set_inline */
+
+		/* copy over customdat */
+		CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
+
+		i++;
+		mvert++;
+
+		BM_CHECK_ELEMENT(bm, v);
+	}
+	bm->elem_index_dirty &= ~BM_VERT;
+
+	med = medge;
+	i = 0;
+	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+		float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
+		float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
+
+		med->v1 = BM_elem_index_get(e->v1);
+		med->v2 = BM_elem_index_get(e->v2);
+		med->crease = crease ? (char)((*crease) * 255) : 0;
+		med->bweight = bweight ? (char)((*bweight) * 255) : 0;
+
+		med->flag = BM_edge_flag_to_mflag(e);
+
+		BM_elem_index_set(e, i); /* set_inline */
+
+		/* copy over customdata */
+		CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
+
+		bmesh_quick_edgedraw_flag(med, e);
+
+		i++;
+		med++;
+		BM_CHECK_ELEMENT(bm, e);
+	}
+	bm->elem_index_dirty &= ~BM_EDGE;
+
+	i = 0;
+	j = 0;
+	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		mpoly->loopstart = j;
+		mpoly->totloop = f->len;
+		mpoly->mat_nr = f->mat_nr;
+		mpoly->flag = BM_face_flag_to_mflag(f);
+
+		l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
+		for ( ; l; l = BM_iter_step(&liter), j++, mloop++) {
+			mloop->e = BM_elem_index_get(l->e);
+			mloop->v = BM_elem_index_get(l->v);
+
+			/* copy over customdat */
+			CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
+			BM_CHECK_ELEMENT(bm, l);
+			BM_CHECK_ELEMENT(bm, l->e);
+			BM_CHECK_ELEMENT(bm, l->v);
+		}
+
+		if (f == bm->act_face) me->act_face = i;
+
+		/* copy over customdata */
+		CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
+
+		i++;
+		mpoly++;
+		BM_CHECK_ELEMENT(bm, f);
+	}
+
+	/* patch hook indices and vertex parents */
+	if (ototvert > 0) {
+		Object *ob;
+		ModifierData *md;
+		BMVert **vertMap = NULL;
+		int i, j;
+
+		for (ob = G.main->object.first; ob; ob = ob->id.next) {
+			if (ob->parent == bm->ob && ELEM(ob->partype, PARVERT1, PARVERT3)) {
+
+				if (vertMap == NULL) {
+					vertMap = bm_to_mesh_vertex_map(bm, ototvert);
+				}
+
+				if (ob->par1 < ototvert) {
+					eve = vertMap[ob->par1];
+					if (eve) ob->par1 = BM_elem_index_get(eve);
+				}
+				if (ob->par2 < ototvert) {
+					eve = vertMap[ob->par2];
+					if (eve) ob->par2 = BM_elem_index_get(eve);
+				}
+				if (ob->par3 < ototvert) {
+					eve = vertMap[ob->par3];
+					if (eve) ob->par3 = BM_elem_index_get(eve);
+				}
+
+			}
+			if (ob->data == me) {
+				for (md = ob->modifiers.first; md; md = md->next) {
+					if (md->type == eModifierType_Hook) {
+						HookModifierData *hmd = (HookModifierData *) md;
+
+						if (vertMap == NULL) {
+							vertMap = bm_to_mesh_vertex_map(bm, ototvert);
+						}
+
+						for (i = j = 0; i < hmd->totindex; i++) {
+							if (hmd->indexar[i] < ototvert) {
+								eve = vertMap[hmd->indexar[i]];
+
+								if (eve) {
+									hmd->indexar[j++] = BM_elem_index_get(eve);
+								}
+							}
+							else j++;
+						}
+
+						hmd->totindex = j;
+					}
+				}
+			}
+		}
+
+		if (vertMap) MEM_freeN(vertMap);
+	}
+
+	if (dotess) {
+		BKE_mesh_tessface_calc(me);
+	}
+
+	mesh_update_customdata_pointers(me, dotess);
+
+	{
+		BMEditSelection *selected;
+		me->totselect = BLI_countlist(&(bm->selected));
+
+		if (me->mselect) MEM_freeN(me->mselect);
+
+		me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
+
+
+		for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
+			if (selected->htype == BM_VERT) {
+				me->mselect[i].type = ME_VSEL;
+
+			}
+			else if (selected->htype == BM_EDGE) {
+				me->mselect[i].type = ME_ESEL;
+
+			}
+			else if (selected->htype == BM_FACE) {
+				me->mselect[i].type = ME_FSEL;
+			}
+
+			me->mselect[i].index = BM_elem_index_get(selected->ele);
+		}
+	}
+
+	/* see comment below, this logic is in twice */
+
+	if (me->key) {
+		KeyBlock *currkey;
+		KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
+
+		float (*ofs)[3] = NULL;
+
+		/* go through and find any shapekey customdata layers
+		 * that might not have corresponding KeyBlocks, and add them if
+		 * necessary */
+		j = 0;
+		for (i = 0; i < bm->vdata.totlayer; i++) {
+			if (bm->vdata.layers[i].type != CD_SHAPEKEY)
+				continue;
+
+			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
+				if (currkey->uid == bm->vdata.layers[i].uid)
+					break;
+			}
+
+			if (!currkey) {
+				currkey = MEM_callocN(sizeof(KeyBlock), "KeyBlock mesh_conv.c");
+				currkey->type = KEY_LINEAR;
+				currkey->slidermin = 0.0f;
+				currkey->slidermax = 1.0f;
+
+				BLI_addtail(&me->key->block, currkey);
+				me->key->totkey++;
+			}
+
+			j++;
+		}
+
+
+		/* editing the base key should update others */
+		if (me->key->type == KEY_RELATIVE && oldverts) {
+			int act_is_basis = 0;
+			/* find if this key is a basis for any others */
+			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
+				if (bm->shapenr - 1 == currkey->relative) {
+					act_is_basis = 1;
+					break;
+				}
+			}
+
+			if (act_is_basis) { /* active key is a base */
+				float (*fp)[3] = actkey->data;
+				int *keyi;
+				i = 0;
+				ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
+				mvert = me->mvert;
+				BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+					keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
+					if (keyi && *keyi != ORIGINDEX_NONE) {
+						sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
+					}
+					i++;
+					mvert++;
+				}
+			}
+		}
+
+
+		for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
+			j = 0;
+
+			for (i = 0; i < bm->vdata.totlayer; i++) {
+				if (bm->vdata.layers[i].type != CD_SHAPEKEY)
+					continue;
+
+				if (currkey->uid == bm->vdata.layers[i].uid) {
+					int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
+					float *fp, *co;
+					float (*ofs_pt)[3] = ofs;
+
+					if (currkey->data)
+						MEM_freeN(currkey->data);
+					currkey->data = fp = MEM_mallocN(sizeof(float) * 3 * bm->totvert, "shape key data");
+					currkey->totelem = bm->totvert;
+
+					mvert = me->mvert;
+					BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+						co = (currkey == actkey) ?
+						            eve->co :
+						            CustomData_bmesh_get_n(&bm->vdata, eve->head.data, CD_SHAPEKEY, j);
+
+						copy_v3_v3(fp, co);
+
+						/* propagate edited basis offsets to other shapes */
+						if (apply_offset) {
+							add_v3_v3(fp, *ofs_pt++);
+						}
+
+						if (currkey == actkey && oldverts) {
+							keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
+
+							if (*keyi >= 0 && *keyi < currkey->totelem) // valid old vertex
+								copy_v3_v3(mvert->co, oldverts[*keyi].co);
+
+							mvert++;
+						}
+
+						fp += 3;
+					}
+					break;
+				}
+
+				j++;
+			}
+
+			/* if we didn't find a shapekey, tag the block to be reconstructed
+			 * via the old method below */
+			if (j == CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY)) {
+				currkey->flag |= KEYBLOCK_MISSING;
+			}
+		}
+
+		if (ofs) MEM_freeN(ofs);
+	}
+
+	/* XXX, code below is from trunk and a duplicate functionality
+	 * to the block above.
+	 * We should use one or the other, having both means we have to maintain
+	 * both and keep them working the same way which is a hassle - campbell */
+
+	/* old method of reconstructing keys via vertice's original key indices,
+	 * currently used if the new method above fails (which is theoretically
+	 * possible in certain cases of undo) */
+	if (me->key) {
+		float *fp, *newkey, *oldkey;
+		KeyBlock *currkey;
+		KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
+
+		float (*ofs)[3] = NULL;
+
+		/* editing the base key should update others */
+		if (me->key->type == KEY_RELATIVE && oldverts) {
+			int act_is_basis = 0;
+			/* find if this key is a basis for any others */
+			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
+				if (bm->shapenr - 1 == currkey->relative) {
+					act_is_basis = 1;
+					break;
+				}
+			}
+
+			if (act_is_basis) { /* active key is a base */
+				float (*fp)[3] = actkey->data;
+				int *keyi;
+				i = 0;
+				ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
+				mvert = me->mvert;
+				BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+					keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
+					if (keyi && *keyi != ORIGINDEX_NONE) {
+						sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
+					}
+					i++;
+					mvert++;
+				}
+			}
+		}
+
+		/* Lets reorder the key data so that things line up roughly
+		 * with the way things were before editmode */
+		currkey = me->key->block.first;
+		while (currkey) {
+			int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
+
+			if (!(currkey->flag & KEYBLOCK_MISSING)) {
+				currkey = currkey->next;
+				continue;
+			}
+
+			printf("warning: had to hackishly reconstruct shape key \"%s\","
+			       " it may not be correct anymore.\n", currkey->name);
+
+			currkey->flag &= ~KEYBLOCK_MISSING;
+
+			fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert,  "currkey->data");
+			oldkey = currkey->data;
+
+			eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
+
+			i = 0;
+			mvert = me->mvert;
+			while (eve) {
+				keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
+				if (!keyi) {
+					break;
+				}
+				if (*keyi >= 0 && *keyi < currkey->totelem) { // valid old vertex
+					if (currkey == actkey) {
+						if (actkey == me->key->refkey) {
+							copy_v3_v3(fp, mvert->co);
+						}
+						else {
+							copy_v3_v3(fp, mvert->co);
+							if (oldverts) {
+								copy_v3_v3(mvert->co, oldverts[*keyi].co);
+							}
+						}
+					}
+					else {
+						if (oldkey) {
+							copy_v3_v3(fp, oldkey + 3 * *keyi);
+						}
+					}
+				}
+				else {
+					copy_v3_v3(fp, mvert->co);
+				}
+
+				/* propagate edited basis offsets to other shapes */
+				if (apply_offset) {
+					add_v3_v3(fp, ofs[i]);
+				}
+
+				fp += 3;
+				i++;
+				mvert++;
+				eve = BM_iter_step(&iter);
+			}
+			currkey->totelem = bm->totvert;
+			if (currkey->data) MEM_freeN(currkey->data);
+			currkey->data = newkey;
+
+			currkey = currkey->next;
+		}
+
+		if (ofs) MEM_freeN(ofs);
+	}
+
+	if (oldverts) MEM_freeN(oldverts);
+}
diff --git a/source/blender/bmesh/intern/bmesh_mesh_conv.h b/source/blender/bmesh/intern/bmesh_mesh_conv.h
new file mode 100644
index 00000000000..f1b820767d4
--- /dev/null
+++ b/source/blender/bmesh/intern/bmesh_mesh_conv.h
@@ -0,0 +1,40 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2004 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Geoffrey Bantle.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __BMESH_MESH_CONV_H__
+#define __BMESH_MESH_CONV_H__
+
+/** \file blender/bmesh/intern/bmesh_mesh_conv.h
+ *  \ingroup bmesh
+ */
+
+struct Mesh;
+
+void BM_mesh_to_bmesh(BMesh *bm, struct Mesh *me, int set_key, int act_key_nr);
+void BM_mesh_from_bmesh(BMesh *bm, struct Mesh *me, int dotess);
+
+#endif /* __BMESH_MESH_CONV_H__ */
diff --git a/source/blender/bmesh/operators/bmo_mesh_conv.c b/source/blender/bmesh/operators/bmo_mesh_conv.c
index 16c1289f5fa..3e0fc881bfa 100644
--- a/source/blender/bmesh/operators/bmo_mesh_conv.c
+++ b/source/blender/bmesh/operators/bmo_mesh_conv.c
@@ -55,314 +55,13 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 {
 	Object *ob = BMO_slot_ptr_get(op, "object");
 	Mesh *me = BMO_slot_ptr_get(op, "mesh");
-	MVert *mvert;
-	BLI_array_declare(verts);
-	MEdge *medge;
-	MLoop *ml;
-	MPoly *mpoly;
-	KeyBlock *actkey, *block;
-	BMVert *v, **vt = NULL, **verts = NULL;
-	BMEdge *e, **fedges = NULL, **et = NULL;
-	BMFace *f;
-	BMLoop *l;
-	BLI_array_declare(fedges);
-	float (*keyco)[3] = NULL;
-	int *keyi;
 	int set_key = BMO_slot_bool_get(op, "set_shapekey");
-	int totuv, i, j;
-
-	if (!me || !me->totvert) {
-		return; /* sanity check */
-	}
-	
-	vt = MEM_mallocN(sizeof(void **) * me->totvert, "mesh to bmesh vtable");
-
-	CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
-	CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
-	CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
-	CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
-	
-	/* make sure uv layer names are consisten */
-	totuv = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
-	for (i = 0; i < totuv; i++) {
-		int li = CustomData_get_layer_index_n(&bm->pdata, CD_MTEXPOLY, i);
-		CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
-	}
-	
-	if (!CustomData_has_layer(&bm->edata, CD_CREASE))
-		CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
-
-	if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
-		CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
-
-	if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
-		CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
 
+	BM_mesh_to_bmesh(bm, me, set_key, ob->shapenr - 1);
 
 	if (me->key && ob->shapenr > me->key->totkey) {
 		ob->shapenr = me->key->totkey - 1;
 	}
-
-	actkey = ob_get_keyblock(ob);
-	if (actkey && actkey->totelem == me->totvert) {
-		CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
-		
-		/* check if we need to generate unique ids for the shapekeys.
-		 * this also exists in the file reading code, but is here for
-		 * a sanity chec */
-		if (!me->key->uidgen) {
-			fprintf(stderr,
-			        "%s had to generate shape key uid's in a situation we shouldn't need to! "
-			        "(bmesh internal error)\n",
-			        __func__);
-
-			me->key->uidgen = 1;
-			for (block = me->key->block.first; block; block = block->next) {
-				block->uid = me->key->uidgen++;
-			}
-		}
-
-		keyco = actkey->data;
-		bm->shapenr = ob->shapenr;
-		for (i = 0, block = me->key->block.first; block; block = block->next, i++) {
-			CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
-			                           CD_ASSIGN, NULL, 0, block->name);
-			
-			j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
-			bm->vdata.layers[j].uid = block->uid;
-		}
-	}
-	else if (actkey) {
-		printf("shapekey <-> mesh mismatch!\n");
-	}
-	
-	CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
-	CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
-	CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
-	CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
-
-	for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
-		v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
-		BM_elem_index_set(v, i); /* set_ok */
-		vt[i] = v;
-
-		/* transfer flag */
-		v->head.hflag = BM_vert_flag_from_mflag(mvert->flag);
-
-		/* this is necessary for selection counts to work properl */
-        if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
-            BM_vert_select_set(bm, v, TRUE);
-        }
-
-		normal_short_to_float_v3(v->no, mvert->no);
-
-		BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
-
-		/* Copy Custom Dat */
-		CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
-
-		/* set shapekey dat */
-		if (me->key) {
-			/* set shape key original inde */
-			keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
-			if (keyi) {
-				*keyi = i;
-			}
-			
-			for (block = me->key->block.first, j = 0; block; block = block->next, j++) {
-				float *co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, j);
-
-				if (co) {
-					copy_v3_v3(co, ((float *)block->data) + 3 * i);
-				}
-			}
-		}
-	}
-
-	bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
-
-	if (!me->totedge) {
-		MEM_freeN(vt);
-		return;
-	}
-
-	et = MEM_mallocN(sizeof(void **) * me->totedge, "mesh to bmesh etable");
-
-	medge = me->medge;
-	for (i = 0; i < me->totedge; i++, medge++) {
-		e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
-		BM_elem_index_set(e, i); /* set_ok */
-		et[i] = e;
-
-		/* transfer flags */
-		e->head.hflag = BM_edge_flag_from_mflag(medge->flag);
-
-		/* this is necessary for selection counts to work properly */
-		if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE);
-		
-		/* Copy Custom Dat */
-		CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
-		
-		BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
-		BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
-	}
-
-	bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
-
-	mpoly = me->mpoly;
-	for (i = 0; i < me->totpoly; i++, mpoly++) {
-		BMIter iter;
-
-		BLI_array_empty(fedges);
-		BLI_array_empty(verts);
-
-		BLI_array_growitems(fedges, mpoly->totloop);
-		BLI_array_growitems(verts, mpoly->totloop);
-
-		for (j = 0; j < mpoly->totloop; j++) {
-			ml = &me->mloop[mpoly->loopstart + j];
-			v = vt[ml->v];
-			e = et[ml->e];
-
-			fedges[j] = e;
-			verts[j] = v;
-		}
-		
-		/* not sure what this block is supposed to do,
-		 * but its unused. so commenting - campbell */
-#if 0
-		{
-			BMVert *v1, *v2;
-			v1 = vt[me->mloop[mpoly->loopstart].v];
-			v2 = vt[me->mloop[mpoly->loopstart + 1].v];
-
-			if (v1 == fedges[0]->v1) {
-				v2 = fedges[0]->v2;
-			}
-			else {
-				v1 = fedges[0]->v2;
-				v2 = fedges[0]->v1;
-			}
-		}
-#endif
-
-		f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
-
-		if (!f) {
-			printf("%s: Warning! Bad face in mesh"
-			       " \"%s\" at index %d!, skipping\n",
-			       __func__, me->id.name + 2, i);
-			continue;
-		}
-
-		/* dont use 'i' since we may have skipped the face */
-		BM_elem_index_set(f, bm->totface - 1); /* set_ok */
-
-		/* transfer flag */
-		f->head.hflag = BM_face_flag_from_mflag(mpoly->flag);
-
-		/* this is necessary for selection counts to work properl */
-		if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE);
-
-		f->mat_nr = mpoly->mat_nr;
-		if (i == me->act_face) bm->act_face = f;
-
-		j = 0;
-		BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
-			/* Save index of correspsonding MLoop */
-			BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
-		}
-
-		/* Copy Custom Data */
-		CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
-	}
-
-	bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
-
-	{
-		BMIter fiter;
-		BMIter liter;
-		
-		/* Copy over loop CustomData. Doing this in a separate loop isn't necessary
-		 * but is an optimization, to avoid copying a bunch of interpolated customdata
-		 * for each BMLoop (from previous BMLoops using the same edge), always followed
-		 * by freeing the interpolated data and overwriting it with data from the Mesh. */
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
-			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
-				int li = BM_elem_index_get(l);
-				CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
-				BM_elem_index_set(l, 0); /* set_loop */
-			}
-		}
-	}
-
-	if (me->mselect && me->totselect != 0) {
-		BMIter iter;
-		BMVert *vertex;
-		BMEdge *edge;
-		BMFace *face;
-		BMVert **vertex_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
-		                                    "Selection Conversion Vertex Pointer Array");
-		BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
-		                                  "Selection Conversion Edge Pointer Array");
-		BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
-		                                  "Selection Conversion Face Pointer Array");
-
-		for (i = 0, vertex = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
-		     vertex;
-		     i++, vertex = BM_iter_step(&iter))
-		{
-			vertex_array[i] = vertex;
-		}
-
-		for (i = 0, edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
-		     edge;
-		     i++, edge = BM_iter_step(&iter))
-		{
-			edge_array[i] = edge;
-		}
-
-		for (i = 0, face = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
-		     face;
-		     i++, face = BM_iter_step(&iter))
-		{
-			face_array[i] = face;
-		}
-
-		if (me->mselect) {
-			for (i = 0; i < me->totselect; i++) {
-				if (me->mselect[i].type == ME_VSEL) {
-					BM_select_history_store(bm, (BMElem *)vertex_array[me->mselect[i].index]);
-				}
-				else if (me->mselect[i].type == ME_ESEL) {
-					BM_select_history_store(bm, (BMElem *)edge_array[me->mselect[i].index]);
-				}
-				else if (me->mselect[i].type == ME_FSEL) {
-					BM_select_history_store(bm, (BMElem *)face_array[me->mselect[i].index]);
-				}
-			}
-		}
-		else {
-			me->totselect = 0;
-		}
-
-		MEM_freeN(vertex_array);
-		MEM_freeN(edge_array);
-		MEM_freeN(face_array);
-	}
-	else {
-		me->totselect = 0;
-		if (me->mselect) {
-			MEM_freeN(me->mselect);
-			me->mselect = NULL;
-		}
-	}
-
-	BLI_array_free(fedges);
-	BLI_array_free(verts);
-	
-	MEM_freeN(vt);
-	MEM_freeN(et);
 }
 
 void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
@@ -374,544 +73,11 @@ void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
 	BMO_op_callf(bm, "bmesh_to_mesh mesh=%p object=%p notessellation=%b", me, ob, TRUE);
 }
 
-
-static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
-{
-	BMVert **vertMap = NULL;
-	BMVert *eve;
-	int index;
-	int i = 0;
-	BMIter iter;
-
-	/* caller needs to ensure this */
-	BLI_assert(ototvert > 0);
-
-	vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
-	if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
-		int *keyi;
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-			keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-			if (keyi) {
-				if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
-					vertMap[index] = eve;
-				}
-			}
-			else {
-				if (i < ototvert) {
-					vertMap[i] = eve;
-				}
-			}
-			i++;
-		}
-	}
-	else {
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-			if (i < ototvert) {
-				vertMap[i] = eve;
-			}
-			else {
-				break;
-			}
-			i++;
-		}
-	}
-
-	return vertMap;
-}
-
-BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
-{
-	/* this is a cheap way to set the edge draw, its not precise and will
-	 * pick the first 2 faces an edge uses */
-
-
-	if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
-	     (e->l && (e->l != e->l->radial_next)) &&
-	     (dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.998f))
-	{
-		med->flag &= ~ME_EDGEDRAW;
-	}
-}
-
-
 void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 {
 	Mesh *me = BMO_slot_ptr_get(op, "mesh");
 	/* Object *ob = BMO_slot_ptr_get(op, "object"); */
-	MLoop *mloop;
-	MPoly *mpoly;
-	MVert *mvert, *oldverts;
-	MEdge *med, *medge;
-	BMVert *v, *eve;
-	BMEdge *e;
-	BMLoop *l;
-	BMFace *f;
-	BMIter iter, liter;
-	int i, j, *keyi, ototvert, totloop;
 	int dotess = !BMO_slot_bool_get(op, "notessellation");
-	
-	ototvert = me->totvert;
-
-	/* new Vertex block */
-	if (bm->totvert == 0) mvert = NULL;
-	else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
-
-	/* new Edge block */
-	if (bm->totedge == 0) medge = NULL;
-	else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
-	
-	/* build ngon dat */
-	/* new Ngon Face block */
-	if (bm->totface == 0) mpoly = NULL;
-	else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
-	
-	/* find number of loops to allocat */
-	totloop = 0;
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
-		totloop += f->len;
-	}
-
-	if (totloop == 0) mloop = NULL;
-	else mloop = MEM_callocN(totloop * sizeof(MLoop), "loadeditbMesh loop");
-
-	/* lets save the old verts just in case we are actually working on
-	 * a key ... we now do processing of the keys at the end */
-	oldverts = me->mvert;
-
-	/* don't free this yet */
-	CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
-
-	/* free custom data */
-	CustomData_free(&me->vdata, me->totvert);
-	CustomData_free(&me->edata, me->totedge);
-	CustomData_free(&me->fdata, me->totface);
-	CustomData_free(&me->ldata, me->totloop);
-	CustomData_free(&me->pdata, me->totpoly);
-
-	/* add new custom data */
-	me->totvert = bm->totvert;
-	me->totedge = bm->totedge;
-	me->totloop = totloop;
-	me->totpoly = bm->totface;
-	/* will be overwritten with a valid value if 'dotess' is set, otherwise we
-	 * end up with 'me->totface' and me->mface == NULL which can crash [#28625]
-	 */
-	me->totface = 0;
-
-	CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
-	CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
-	CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
-	CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
-
-	CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
-	CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
-	CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
-	CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
-
-	/* this is called again, 'dotess' arg is used there */
-	mesh_update_customdata_pointers(me, 0);
-	
-	i = 0;
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-		float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
-
-		mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
-
-		copy_v3_v3(mvert->co, v->co);
-		normal_float_to_short_v3(mvert->no, v->no);
-		
-		mvert->flag = BM_vert_flag_to_mflag(v);
-
-		BM_elem_index_set(v, i); /* set_inline */
-
-		/* copy over customdat */
-		CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
-
-		i++;
-		mvert++;
-
-		BM_CHECK_ELEMENT(bm, v);
-	}
-	bm->elem_index_dirty &= ~BM_VERT;
-
-	med = medge;
-	i = 0;
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
-		float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
-		float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
-		
-		med->v1 = BM_elem_index_get(e->v1);
-		med->v2 = BM_elem_index_get(e->v2);
-		med->crease = crease ? (char)((*crease) * 255) : 0;
-		med->bweight = bweight ? (char)((*bweight) * 255) : 0;
-		
-		med->flag = BM_edge_flag_to_mflag(e);
-		
-		BM_elem_index_set(e, i); /* set_inline */
-
-		/* copy over customdat */
-		CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
-
-		bmesh_quick_edgedraw_flag(med, e);
-
-		i++;
-		med++;
-		BM_CHECK_ELEMENT(bm, e);
-	}
-	bm->elem_index_dirty &= ~BM_EDGE;
-
-	i = 0;
-	j = 0;
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
-		mpoly->loopstart = j;
-		mpoly->totloop = f->len;
-		mpoly->mat_nr = f->mat_nr;
-		mpoly->flag = BM_face_flag_to_mflag(f);
-
-		l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
-		for ( ; l; l = BM_iter_step(&liter), j++, mloop++) {
-			mloop->e = BM_elem_index_get(l->e);
-			mloop->v = BM_elem_index_get(l->v);
-
-			/* copy over customdat */
-			CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
-			BM_CHECK_ELEMENT(bm, l);
-			BM_CHECK_ELEMENT(bm, l->e);
-			BM_CHECK_ELEMENT(bm, l->v);
-		}
-		
-		if (f == bm->act_face) me->act_face = i;
-
-		/* copy over customdat */
-		CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
-
-		i++;
-		mpoly++;
-		BM_CHECK_ELEMENT(bm, f);
-	}
-
-	/* patch hook indices and vertex parents */
-	if (ototvert > 0) {
-		Object *ob;
-		ModifierData *md;
-		BMVert **vertMap = NULL;
-		int i, j;
-
-		for (ob = G.main->object.first; ob; ob = ob->id.next) {
-			if (ob->parent == bm->ob && ELEM(ob->partype, PARVERT1, PARVERT3)) {
-
-				if (vertMap == NULL) {
-					vertMap = bm_to_mesh_vertex_map(bm, ototvert);
-				}
-
-				if (ob->par1 < ototvert) {
-					eve = vertMap[ob->par1];
-					if (eve) ob->par1 = BM_elem_index_get(eve);
-				}
-				if (ob->par2 < ototvert) {
-					eve = vertMap[ob->par2];
-					if (eve) ob->par2 = BM_elem_index_get(eve);
-				}
-				if (ob->par3 < ototvert) {
-					eve = vertMap[ob->par3];
-					if (eve) ob->par3 = BM_elem_index_get(eve);
-				}
-				
-			}
-			if (ob->data == me) {
-				for (md = ob->modifiers.first; md; md = md->next) {
-					if (md->type == eModifierType_Hook) {
-						HookModifierData *hmd = (HookModifierData *) md;
-
-						if (vertMap == NULL) {
-							vertMap = bm_to_mesh_vertex_map(bm, ototvert);
-						}
-						
-						for (i = j = 0; i < hmd->totindex; i++) {
-							if (hmd->indexar[i] < ototvert) {
-								eve = vertMap[hmd->indexar[i]];
-								
-								if (eve) {
-									hmd->indexar[j++] = BM_elem_index_get(eve);
-								}
-							}
-							else j++;
-						}
-
-						hmd->totindex = j;
-					}
-				}
-			}
-		}
-
-		if (vertMap) MEM_freeN(vertMap);
-	}
-
-	if (dotess) {
-		BKE_mesh_tessface_calc(me);
-	}
-
-	mesh_update_customdata_pointers(me, dotess);
-
-	{
-		BMEditSelection *selected;
-		me->totselect = BLI_countlist(&(bm->selected));
-
-		if (me->mselect) MEM_freeN(me->mselect);
-
-		me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
-
-
-		for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
-			if (selected->htype == BM_VERT) {
-				me->mselect[i].type = ME_VSEL;
-
-			}
-			else if (selected->htype == BM_EDGE) {
-				me->mselect[i].type = ME_ESEL;
-
-			}
-			else if (selected->htype == BM_FACE) {
-				me->mselect[i].type = ME_FSEL;
-			}
-
-			me->mselect[i].index = BM_elem_index_get(selected->ele);
-		}
-	}
-
-	/* see comment below, this logic is in twice */
-
-	if (me->key) {
-		KeyBlock *currkey;
-		KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
-
-		float (*ofs)[3] = NULL;
-
-		/* go through and find any shapekey customdata layers
-		 * that might not have corresponding KeyBlocks, and add them if
-		 * necessary */
-		j = 0;
-		for (i = 0; i < bm->vdata.totlayer; i++) {
-			if (bm->vdata.layers[i].type != CD_SHAPEKEY)
-				continue;
-
-			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
-				if (currkey->uid == bm->vdata.layers[i].uid)
-					break;
-			}
-			
-			if (!currkey) {
-				currkey = MEM_callocN(sizeof(KeyBlock), "KeyBlock mesh_conv.c");
-				currkey->type = KEY_LINEAR;
-				currkey->slidermin = 0.0f;
-				currkey->slidermax = 1.0f;
-
-				BLI_addtail(&me->key->block, currkey);
-				me->key->totkey++;
-			}
-
-			j++;
-		}
-
-
-		/* editing the base key should update others */
-		if (me->key->type == KEY_RELATIVE && oldverts) {
-			int act_is_basis = 0;
-			/* find if this key is a basis for any others */
-			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
-				if (bm->shapenr - 1 == currkey->relative) {
-					act_is_basis = 1;
-					break;
-				}
-			}
-
-			if (act_is_basis) { /* active key is a base */
-				float (*fp)[3] = actkey->data;
-				int *keyi;
-				i = 0;
-				ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
-				mvert = me->mvert;
-				BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-					keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-					if (keyi && *keyi != ORIGINDEX_NONE) {
-						sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
-					}
-					i++;
-					mvert++;
-				}
-			}
-		}
-
-
-		for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
-			j = 0;
-
-			for (i = 0; i < bm->vdata.totlayer; i++) {
-				if (bm->vdata.layers[i].type != CD_SHAPEKEY)
-					continue;
-
-				if (currkey->uid == bm->vdata.layers[i].uid) {
-					int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
-					float *fp, *co;
-					float (*ofs_pt)[3] = ofs;
-
-					if (currkey->data)
-						MEM_freeN(currkey->data);
-					currkey->data = fp = MEM_mallocN(sizeof(float) * 3 * bm->totvert, "shape key data");
-					currkey->totelem = bm->totvert;
-
-					mvert = me->mvert;
-					BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-						co = (currkey == actkey) ?
-						            eve->co :
-						            CustomData_bmesh_get_n(&bm->vdata, eve->head.data, CD_SHAPEKEY, j);
-						
-						copy_v3_v3(fp, co);
-
-						/* propagate edited basis offsets to other shapes */
-						if (apply_offset) {
-							add_v3_v3(fp, *ofs_pt++);
-						}
-
-						if (currkey == actkey && oldverts) {
-							keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-
-							if (*keyi >= 0 && *keyi < currkey->totelem) // valid old vertex
-								copy_v3_v3(mvert->co, oldverts[*keyi].co);
-
-							mvert++;
-						}
-
-						fp += 3;
-					}
-					break;
-				}
-
-				j++;
-			}
-
-			/* if we didn't find a shapekey, tag the block to be reconstructed
-			 * via the old method below */
-			if (j == CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY)) {
-				currkey->flag |= KEYBLOCK_MISSING;
-			}
-		}
-
-		if (ofs) MEM_freeN(ofs);
-	}
-
-	/* XXX, code below is from trunk and a duplicate functionality
-	 * to the block above.
-	 * We should use one or the other, having both means we have to maintain
-	 * both and keep them working the same way which is a hassle - campbell */
-
-	/* old method of reconstructing keys via vertice's original key indices,
-	 * currently used if the new method above fails (which is theoretically
-	 * possible in certain cases of undo) */
-	if (me->key) {
-		float *fp, *newkey, *oldkey;
-		KeyBlock *currkey;
-		KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
-
-		float (*ofs)[3] = NULL;
-
-		/* editing the base key should update others */
-		if (me->key->type == KEY_RELATIVE && oldverts) {
-			int act_is_basis = 0;
-			/* find if this key is a basis for any others */
-			for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
-				if (bm->shapenr - 1 == currkey->relative) {
-					act_is_basis = 1;
-					break;
-				}
-			}
-
-			if (act_is_basis) { /* active key is a base */
-				float (*fp)[3] = actkey->data;
-				int *keyi;
-				i = 0;
-				ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
-				mvert = me->mvert;
-				BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-					keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-					if (keyi && *keyi != ORIGINDEX_NONE) {
-						sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
-					}
-					i++;
-					mvert++;
-				}
-			}
-		}
-
-		/* Lets reorder the key data so that things line up roughly
-		 * with the way things were before editmode */
-		currkey = me->key->block.first;
-		while (currkey) {
-			int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
-
-			if (!(currkey->flag & KEYBLOCK_MISSING)) {
-				currkey = currkey->next;
-				continue;
-			}
-			
-			printf("warning: had to hackishly reconstruct shape key \"%s\","
-			       " it may not be correct anymore.\n", currkey->name);
-
-			currkey->flag &= ~KEYBLOCK_MISSING;
-
-			fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert,  "currkey->data");
-			oldkey = currkey->data;
-
-			eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
-
-			i = 0;
-			mvert = me->mvert;
-			while (eve) {
-				keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-				if (!keyi) {
-					break;
-				}
-				if (*keyi >= 0 && *keyi < currkey->totelem) { // valid old vertex
-					if (currkey == actkey) {
-						if (actkey == me->key->refkey) {
-							copy_v3_v3(fp, mvert->co);
-						}
-						else {
-							copy_v3_v3(fp, mvert->co);
-							if (oldverts) {
-								copy_v3_v3(mvert->co, oldverts[*keyi].co);
-							}
-						}
-					}
-					else {
-						if (oldkey) {
-							copy_v3_v3(fp, oldkey + 3 * *keyi);
-						}
-					}
-				}
-				else {
-					copy_v3_v3(fp, mvert->co);
-				}
-
-				/* propagate edited basis offsets to other shapes */
-				if (apply_offset) {
-					add_v3_v3(fp, ofs[i]);
-				}
-
-				fp += 3;
-				i++;
-				mvert++;
-				eve = BM_iter_step(&iter);
-			}
-			currkey->totelem = bm->totvert;
-			if (currkey->data) MEM_freeN(currkey->data);
-			currkey->data = newkey;
-			
-			currkey = currkey->next;
-		}
-
-		if (ofs) MEM_freeN(ofs);
-	}
 
-	if (oldverts) MEM_freeN(oldverts);
+	BM_mesh_from_bmesh(bm, me, dotess);
 }
diff --git a/source/blender/python/bmesh/bmesh_py_api.c b/source/blender/python/bmesh/bmesh_py_api.c
index 77b19026501..3990005d139 100644
--- a/source/blender/python/bmesh/bmesh_py_api.c
+++ b/source/blender/python/bmesh/bmesh_py_api.c
@@ -40,13 +40,36 @@
 #include "BLI_utildefines.h"
 
 #include "BKE_tessmesh.h"
+#include "BKE_depsgraph.h"
 
 #include "DNA_mesh_types.h"
+#include "DNA_object_types.h"
 
 #include "../generic/py_capi_utils.h"
 
 #include "bmesh_py_api.h" /* own include */
 
+
+
+PyDoc_STRVAR(bpy_bm_new_doc,
+".. method:: new()\n"
+"\n"
+"   :return: Retyrn a new, empty mesh.\n"
+"   :rtype: :class:`BMesh`\n"
+);
+
+static PyObject *bpy_bm_new(PyObject *UNUSED(self))
+{
+	BPy_BMesh *py_bmesh;
+	BMesh *bm;
+
+	bm = BM_mesh_create(NULL, &bm_mesh_allocsize_default);
+
+	py_bmesh = (BPy_BMesh *)BPy_BMesh_CreatePyObject(bm);
+	py_bmesh->py_owns = TRUE;
+	return (PyObject *)py_bmesh;
+}
+
 PyDoc_STRVAR(bpy_bm_from_mesh_doc,
 ".. method:: from_mesh(mesh)\n"
 "\n"
@@ -58,26 +81,78 @@ PyDoc_STRVAR(bpy_bm_from_mesh_doc,
 
 static PyObject *bpy_bm_from_mesh(PyObject *UNUSED(self), PyObject *value)
 {
+	BPy_BMesh *py_bmesh;
+	BMesh *bm;
 	Mesh *me = PyC_RNA_AsPointer(value, "Mesh");
+	int py_owns;
 
-	if (me) {
-		/* temp! */
-		if (!me->edit_btmesh) {
-			PyErr_SetString(PyExc_ValueError,
-							"Mesh is not in editmode");
-			return NULL;
-		}
+	if (me == NULL) {
+		return NULL;
+	}
 
-		return BPy_BMesh_CreatePyObject(me->edit_btmesh->bm);
+	/* temp! */
+	if (!me->edit_btmesh) {
+		bm = BM_mesh_create(NULL, &bm_mesh_allocsize_default);
+		BM_mesh_to_bmesh(bm, me, 0, 0); /* BMESH_TODO add args */
+		py_owns = TRUE;
 	}
 	else {
+		bm = me->edit_btmesh->bm;
+		py_owns = FALSE;
+	}
+
+	py_bmesh = (BPy_BMesh *)BPy_BMesh_CreatePyObject(bm);
+	py_bmesh->py_owns = py_owns;
+	return (PyObject *)py_bmesh;
+}
+
+PyDoc_STRVAR(bpy_bm_to_mesh_doc,
+".. method:: to_mesh(mesh, bmesh)\n"
+"\n"
+"   Return a BMesh from this mesh, currently the mesh must already be in editmode.\n"
+"\n"
+"   :return: the BMesh assosiated with this mesh.\n"
+"   :rtype: :class:`bmesh.types.BMesh`\n"
+);
+
+static PyObject *bpy_bm_to_mesh(PyObject *UNUSED(self), PyObject *args)
+{
+	PyObject  *py_mesh;
+	BPy_BMesh *py_bmesh;
+	Mesh  *me;
+	BMesh *bm;
+
+	if (!PyArg_ParseTuple(args, "OO!:to_mesh", &py_mesh, &BPy_BMesh_Type, &py_bmesh) ||
+	    !(me = PyC_RNA_AsPointer(py_mesh, "Mesh")))
+	{
 		return NULL;
 	}
+
+	BPY_BM_CHECK_OBJ(py_bmesh);
+
+	if (me->edit_btmesh) {
+		PyErr_Format(PyExc_ValueError,
+		             "to_mesh(): Mesh '%s' is in editmode", me->id.name + 2);
+		return NULL;
+	}
+
+	bm = py_bmesh->bm;
+
+	BM_mesh_from_bmesh(bm, me, FALSE);
+
+	/* we could have the user do this but if they forget blender can easy crash
+	 * since the references arrays for the objects derived meshes are now invalid */
+	DAG_id_tag_update(&me->id, OB_RECALC_DATA);
+
+	Py_RETURN_NONE;
 }
 
 static struct PyMethodDef BPy_BM_methods[] = {
-	{"from_mesh", (PyCFunction)bpy_bm_from_mesh, METH_O, bpy_bm_from_mesh_doc},
-	{NULL, NULL, 0, NULL}
+    /* THESE NAMES MAY CHANGE! */
+    {"new",       (PyCFunction)bpy_bm_new,       METH_NOARGS,  bpy_bm_new_doc},
+    {"from_mesh", (PyCFunction)bpy_bm_from_mesh, METH_O,       bpy_bm_from_mesh_doc},
+    {"to_mesh",   (PyCFunction)bpy_bm_to_mesh,   METH_VARARGS, bpy_bm_to_mesh_doc},
+    {NULL, NULL, 0, NULL}
 };
 
 PyDoc_STRVAR(BPy_BM_doc,
diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c
index 812e958dea3..c15323186ac 100644
--- a/source/blender/python/bmesh/bmesh_py_types.c
+++ b/source/blender/python/bmesh/bmesh_py_types.c
@@ -2062,6 +2062,10 @@ static void bpy_bmesh_dealloc(BPy_BMesh *self)
 		bm->py_handle = NULL;
 	}
 
+	if (self->py_owns) {
+		BM_mesh_free(bm);
+	}
+
 	PyObject_DEL(self);
 }
 
diff --git a/source/blender/python/bmesh/bmesh_py_types.h b/source/blender/python/bmesh/bmesh_py_types.h
index fab5a52f98e..52a82c50dd1 100644
--- a/source/blender/python/bmesh/bmesh_py_types.h
+++ b/source/blender/python/bmesh/bmesh_py_types.h
@@ -62,6 +62,7 @@ typedef struct BPy_BMElem {
 typedef struct BPy_BMesh {
 	PyObject_VAR_HEAD
 	struct BMesh *bm; /* keep first */
+	char py_owns;
 } BPy_BMesh;
 
 /* element types */