Particle System: ported most DerivedMesh → Mesh

There are a few places where DerivedMesh is still used, most notably
when calling the (not yet ported) cloth simulation. There is also still
the use of Object.derivedDeform and Object.derivedFinal. Those places are
marked with a TODO.

Some functions in the editors module were copied to accept Mesh. Those
already had 'mesh' in the name; the copies are suffixed with '__real_mesh'
for easy renaming later when the DM-based functionality is removed.

3 files changed, 241 insertions, 6 deletions

diff --git a/source/blender/editors/mesh/editmesh_utils.c b/source/blender/editors/mesh/editmesh_utils.c
index e8f3e592715..ab44e017fc6 100644
--- a/source/blender/editors/mesh/editmesh_utils.c
+++ b/source/blender/editors/mesh/editmesh_utils.c
@@ -1030,7 +1030,7 @@ void EDBM_verts_mirror_cache_begin_ex(
 	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 	if (use_topology) {
-		ED_mesh_mirrtopo_init(me, NULL, &mesh_topo_store, true);
+		ED_mesh_mirrtopo_init__real_mesh(me, NULL, &mesh_topo_store, true);
 	}
 	else {
 		tree = BLI_kdtree_new(bm->totvert);
diff --git a/source/blender/editors/mesh/mesh_mirror.c b/source/blender/editors/mesh/mesh_mirror.c
index 22bfd8eedea..4c078d2ac8b 100644
--- a/source/blender/editors/mesh/mesh_mirror.c
+++ b/source/blender/editors/mesh/mesh_mirror.c
@@ -37,6 +37,8 @@
 #include "BKE_DerivedMesh.h"
 #include "BLI_kdtree.h"
 #include "BKE_editmesh.h"
+#include "BKE_library.h"
+#include "BKE_mesh.h"
 
 #include "ED_mesh.h"
 
@@ -93,7 +95,73 @@ int ED_mesh_mirror_spatial_table(Object *ob, BMEditMesh *em, DerivedMesh *dm, co
 		else {
 			MVert *mvert = dm ? dm->getVertArray(dm) : me->mvert;
 			int i;
-			
+
+			for (i = 0; i < totvert; i++, mvert++) {
+				BLI_kdtree_insert(MirrKdStore.tree, i, mvert->co);
+			}
+		}
+
+		BLI_kdtree_balance(MirrKdStore.tree);
+	}
+	else if (mode == 'e') { /* end table */
+		if (MirrKdStore.tree) {
+			BLI_kdtree_free(MirrKdStore.tree);
+			MirrKdStore.tree = NULL;
+		}
+	}
+	else {
+		BLI_assert(0);
+	}
+
+	return 0;
+}
+
+/* mode is 's' start, or 'e' end, or 'u' use */
+/* if end, ob can be NULL */
+int ED_mesh_mirror_spatial_table__real_mesh(Object *ob, BMEditMesh *em, Mesh *mesh, const float co[3], char mode)
+{
+	if (mode == 'u') {        /* use table */
+		if (MirrKdStore.tree == NULL)
+			ED_mesh_mirror_spatial_table__real_mesh(ob, em, mesh, NULL, 's');
+
+		if (MirrKdStore.tree) {
+			KDTreeNearest nearest;
+			const int i = BLI_kdtree_find_nearest(MirrKdStore.tree, co, &nearest);
+
+			if (i != -1) {
+				if (nearest.dist < KD_THRESH) {
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+	else if (mode == 's') {   /* start table */
+		Mesh *me = ob->data;
+		const bool use_em = (!mesh && em && me->edit_btmesh == em);
+		const int totvert = use_em ? em->bm->totvert : mesh ? mesh->totvert : me->totvert;
+
+		if (MirrKdStore.tree) /* happens when entering this call without ending it */
+			ED_mesh_mirror_spatial_table__real_mesh(ob, em, mesh, co, 'e');
+
+		MirrKdStore.tree = BLI_kdtree_new(totvert);
+
+		if (use_em) {
+			BMVert *eve;
+			BMIter iter;
+			int i;
+
+			/* this needs to be valid for index lookups later (callers need) */
+			BM_mesh_elem_table_ensure(em->bm, BM_VERT);
+
+			BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
+				BLI_kdtree_insert(MirrKdStore.tree, i, eve->co);
+			}
+		}
+		else {
+			MVert *mvert = mesh ? mesh->mvert : me->mvert;
+			int i;
+
 			for (i = 0; i < totvert; i++, mvert++) {
 				BLI_kdtree_insert(MirrKdStore.tree, i, mvert->co);
 			}
@@ -172,11 +240,62 @@ bool ED_mesh_mirrtopo_recalc_check(Mesh *me, DerivedMesh *dm, MirrTopoStore_t *m
 	}
 
 }
+bool ED_mesh_mirrtopo_recalc_check__real_mesh(Mesh *me, Mesh *dm, MirrTopoStore_t *mesh_topo_store)
+{
+	const bool is_editmode = (me->edit_btmesh != NULL);
+	int totvert;
+	int totedge;
+
+	if (dm) {
+		totvert = dm->totvert;
+		totedge = dm->totedge;
+	}
+	else if (me->edit_btmesh) {
+		totvert = me->edit_btmesh->bm->totvert;
+		totedge = me->edit_btmesh->bm->totedge;
+	}
+	else {
+		totvert = me->totvert;
+		totedge = me->totedge;
+	}
+
+	if ((mesh_topo_store->index_lookup == NULL) ||
+	    (mesh_topo_store->prev_is_editmode != is_editmode) ||
+	    (totvert != mesh_topo_store->prev_vert_tot) ||
+	    (totedge != mesh_topo_store->prev_edge_tot))
+	{
+		return true;
+	}
+	else {
+		return false;
+	}
+
+}
+
 
 void ED_mesh_mirrtopo_init(
         Mesh *me, DerivedMesh *dm, MirrTopoStore_t *mesh_topo_store,
         const bool skip_em_vert_array_init)
 {
+	Mesh *fake_mesh = NULL;
+
+	if (dm != NULL) {
+		/* ED_real_mesh_mirrtopo_init() only uses the counts, not the actual data */
+		fake_mesh = BKE_mesh_new_nomain(dm->getNumVerts(dm), dm->getNumEdges(dm), dm->getNumTessFaces(dm),
+		                                dm->getNumLoops(dm), dm->getNumPolys(dm));
+	}
+
+	ED_mesh_mirrtopo_init__real_mesh(me, fake_mesh, mesh_topo_store, skip_em_vert_array_init);
+
+	if (dm != NULL) {
+		BKE_id_free(NULL, fake_mesh);
+	}
+}
+
+void ED_mesh_mirrtopo_init__real_mesh(
+        Mesh *me, Mesh *dm, MirrTopoStore_t *mesh_topo_store,
+        const bool skip_em_vert_array_init)
+{
 	const bool is_editmode = (me->edit_btmesh != NULL);
 	MEdge *medge = NULL, *med;
 	BMEditMesh *em = dm ?  NULL : me->edit_btmesh;
@@ -208,7 +327,7 @@ void ED_mesh_mirrtopo_init(
 		totvert = em->bm->totvert;
 	}
 	else {
-		totvert = dm ? dm->getNumVerts(dm) : me->totvert;
+		totvert = dm ? dm->totvert : me->totvert;
 	}
 
 	topo_hash = MEM_callocN(totvert * sizeof(MirrTopoHash_t), "TopoMirr");
@@ -224,8 +343,8 @@ void ED_mesh_mirrtopo_init(
 		}
 	}
 	else {
-		totedge = dm ? dm->getNumEdges(dm) : me->totedge;
-		medge = dm ? dm->getEdgeArray(dm) : me->medge;
+		totedge = dm ? dm->totedge : me->totedge;
+		medge = dm ? dm->medge : me->medge;
 
 		for (a = 0, med = medge; a < totedge; a++, med++) {
 			const unsigned int i1 = med->v1, i2 = med->v2;
diff --git a/source/blender/editors/mesh/meshtools.c b/source/blender/editors/mesh/meshtools.c
index 83458127820..9b86f904161 100644
--- a/source/blender/editors/mesh/meshtools.c
+++ b/source/blender/editors/mesh/meshtools.c
@@ -707,6 +707,30 @@ int ED_mesh_mirror_topo_table(
 	return 0;
 }
 
+/* mode is 's' start, or 'e' end, or 'u' use */
+/* if end, ob can be NULL */
+/* note, is supposed return -1 on error, which callers are currently checking for, but is not used so far */
+int ED_mesh_mirror_topo_table__real_mesh(
+        Object *ob, Mesh *mesh, char mode)
+{
+	if (mode == 'u') {        /* use table */
+		if (ED_mesh_mirrtopo_recalc_check__real_mesh(ob->data, mesh, &mesh_topo_store)) {
+			ED_mesh_mirror_topo_table__real_mesh(ob, mesh, 's');
+		}
+	}
+	else if (mode == 's') { /* start table */
+		ED_mesh_mirrtopo_init__real_mesh(ob->data, mesh, &mesh_topo_store, false);
+	}
+	else if (mode == 'e') { /* end table */
+		ED_mesh_mirrtopo_free(&mesh_topo_store);
+	}
+	else {
+		BLI_assert(0);
+	}
+
+	return 0;
+}
+
 /** \} */
 
 
@@ -742,6 +766,38 @@ int mesh_get_x_mirror_vert(Object *ob, DerivedMesh *dm, int index, const bool us
 	}
 }
 
+static int mesh_get_x_mirror_vert_spatial__real_mesh(Object *ob, Mesh *mesh, int index)
+{
+	Mesh *me = ob->data;
+	MVert *mvert = mesh ? mesh->mvert : me->mvert;
+	float vec[3];
+
+	mvert = &mvert[index];
+	vec[0] = -mvert->co[0];
+	vec[1] = mvert->co[1];
+	vec[2] = mvert->co[2];
+
+	return ED_mesh_mirror_spatial_table__real_mesh(ob, NULL, mesh, vec, 'u');
+}
+
+static int mesh_get_x_mirror_vert_topo__real_mesh(Object *ob, Mesh *mesh, int index)
+{
+	if (ED_mesh_mirror_topo_table__real_mesh(ob, mesh, 'u') == -1)
+		return -1;
+
+	return mesh_topo_store.index_lookup[index];
+}
+
+int mesh_get_x_mirror_vert__real_mesh(Object *ob, Mesh *mesh, int index, const bool use_topology)
+{
+	if (use_topology) {
+		return mesh_get_x_mirror_vert_topo__real_mesh(ob, mesh, index);
+	}
+	else {
+		return mesh_get_x_mirror_vert_spatial__real_mesh(ob, mesh, index);
+	}
+}
+
 static BMVert *editbmesh_get_x_mirror_vert_spatial(Object *ob, BMEditMesh *em, const float co[3])
 {
 	float vec[3];
@@ -991,7 +1047,67 @@ int *mesh_get_x_mirror_faces(Object *ob, BMEditMesh *em, DerivedMesh *dm)
 
 	BLI_ghash_free(fhash, NULL, NULL);
 	MEM_freeN(mirrorverts);
-	
+
+	return mirrorfaces;
+}
+
+/* This is a Mesh-based copy of mesh_get_x_mirror_faces() */
+int *mesh_get_x_mirror_faces__real_mesh(Object *ob, BMEditMesh *em, Mesh *mesh)
+{
+	Mesh *me = ob->data;
+	MVert *mv, *mvert;
+	MFace mirrormf, *mf, *hashmf, *mface;
+	GHash *fhash;
+	int *mirrorverts, *mirrorfaces;
+
+	BLI_assert(em == NULL);  /* Does not work otherwise, currently... */
+
+	const bool use_topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
+	const int totvert = mesh ? mesh->totvert : me->totvert;
+	const int totface = mesh ? mesh->totface : me->totface;
+	int a;
+
+	mirrorverts = MEM_callocN(sizeof(int) * totvert, "MirrorVerts");
+	mirrorfaces = MEM_callocN(sizeof(int) * 2 * totface, "MirrorFaces");
+
+	mvert = mesh ? mesh->mvert : me->mvert;
+	mface = mesh ? mesh->mface : me->mface;
+
+	ED_mesh_mirror_spatial_table__real_mesh(ob, em, mesh, NULL, 's');
+
+	for (a = 0, mv = mvert; a < totvert; a++, mv++)
+		mirrorverts[a] = mesh_get_x_mirror_vert__real_mesh(ob, mesh, a, use_topology);
+
+	ED_mesh_mirror_spatial_table__real_mesh(ob, em, mesh, NULL, 'e');
+
+	fhash = BLI_ghash_new_ex(mirror_facehash, mirror_facecmp, "mirror_facehash gh", me->totface);
+	for (a = 0, mf = mface; a < totface; a++, mf++)
+		BLI_ghash_insert(fhash, mf, mf);
+
+	for (a = 0, mf = mface; a < totface; a++, mf++) {
+		mirrormf.v1 = mirrorverts[mf->v3];
+		mirrormf.v2 = mirrorverts[mf->v2];
+		mirrormf.v3 = mirrorverts[mf->v1];
+		mirrormf.v4 = (mf->v4) ? mirrorverts[mf->v4] : 0;
+
+		/* make sure v4 is not 0 if a quad */
+		if (mf->v4 && mirrormf.v4 == 0) {
+			SWAP(unsigned int, mirrormf.v1, mirrormf.v3);
+			SWAP(unsigned int, mirrormf.v2, mirrormf.v4);
+		}
+
+		hashmf = BLI_ghash_lookup(fhash, &mirrormf);
+		if (hashmf) {
+			mirrorfaces[a * 2] = hashmf - mface;
+			mirrorfaces[a * 2 + 1] = mirror_facerotation(&mirrormf, hashmf);
+		}
+		else
+			mirrorfaces[a * 2] = -1;
+	}
+
+	BLI_ghash_free(fhash, NULL, NULL);
+	MEM_freeN(mirrorverts);
+
 	return mirrorfaces;
 }