bmesh operator api:

avoid per vert/edge/face string lookups in BMO_slot_map_* functions --- used in array modifier, subdivide, remove doubles and other tools.

8 files changed, 115 insertions, 78 deletions

diff --git a/source/blender/bmesh/operators/bmo_create.c b/source/blender/bmesh/operators/bmo_create.c
index e9a06631fac..987aa8cdf99 100644
--- a/source/blender/bmesh/operators/bmo_create.c
+++ b/source/blender/bmesh/operators/bmo_create.c
@@ -741,7 +741,10 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E
 	BMVert *startv;
 	BMVert *endv;
 	EPathNode *node;
-	int i, use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict");
+	int i;
+	const int use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict");
+	BMOpSlot *slot_restrict = BMO_slot_get(op->slots_in, "restrict");
+
 
 	startv = edata[BM_elem_index_get(edge)].ftag ? edge->v2 : edge->v1;
 	endv = edata[BM_elem_index_get(edge)].ftag ? edge->v1 : edge->v2;
@@ -806,12 +809,13 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E
 				continue;
 			}
 			
-			if (use_restrict && BMO_slot_map_contains(op->slots_in, "restrict", e)) {
-				int group = BMO_slot_map_int_get(op->slots_in, "restrict", e);
-				
-				if (!(group & path->group)) {
-					v2 = NULL;
-					continue;
+			if (use_restrict) {
+				int *group = (int *)BMO_slot_map_data_get(slot_restrict, e);
+				if (group) {
+					if (!(*group & path->group)) {
+						v2 = NULL;
+						continue;
+					}
 				}
 			}
 
@@ -901,6 +905,8 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 	const short use_smooth = BMO_slot_bool_get(op->slots_in, "use_smooth");
 	int i, j, group = 0;
 	unsigned int winding[2]; /* accumulte winding directions for each edge which has a face */
+	BMOpSlot *slot_restrict          = BMO_slot_get(op->slots_in, "restrict");
+	BMOpSlot *slot_face_groupmap_out = BMO_slot_get(op->slots_out, "face_groupmap.out");
 
 	if (!bm->totvert || !bm->totedge)
 		return;
@@ -932,14 +938,14 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 	bm->elem_index_dirty &= ~BM_EDGE;
 
 	init_rotsys(bm, edata, vdata);
-	
+
 	while (1) {
 		edge = NULL;
 		group = 0;
 		
 		BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) {
 			/* if restrict is on, only start on faces in the restrict map */
-			if (use_restrict && !BMO_slot_map_contains(op->slots_in, "restrict", e))
+			if (use_restrict && !BMO_slot_map_contains(slot_restrict, e))
 				continue;
 
 			if (edata[BM_elem_index_get(e)].tag < 2) {
@@ -948,7 +954,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 				if (use_restrict) {
 					int i = 0, j = 0, gi = 0;
 					
-					group = BMO_slot_map_int_get(op->slots_in, "restrict", e);
+					group = BMO_slot_map_int_get(slot_restrict, e);
 					
 					for (i = 0; i < 30; i++) {
 						if (group & (1 << i)) {
@@ -1055,7 +1061,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 				}
 
 				if (use_restrict) {
-					BMO_slot_map_int_insert(op, op->slots_out, "face_groupmap.out", f, path->group);
+					BMO_slot_map_int_insert(op, slot_face_groupmap_out, f, path->group);
 				}
 			}
 		}
diff --git a/source/blender/bmesh/operators/bmo_dupe.c b/source/blender/bmesh/operators/bmo_dupe.c
index f32ba4430b8..c4f6c821320 100644
--- a/source/blender/bmesh/operators/bmo_dupe.c
+++ b/source/blender/bmesh/operators/bmo_dupe.c
@@ -68,7 +68,9 @@ static BMVert *copy_vertex(BMesh *source_mesh, BMVert *source_vertex, BMesh *tar
  *
  * Copy an existing edge from one bmesh to another.
  */
-static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
+static BMEdge *copy_edge(BMOperator *op,
+                         BMOpSlot *slot_boundarymap_out,
+                         BMesh *source_mesh,
                          BMEdge *source_edge, BMesh *target_mesh,
                          GHash *vhash, GHash *ehash)
 {
@@ -102,7 +104,7 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
 	if (rlen < 2) {
 		/* not sure what non-manifold cases of greater then three
 		 * radial should do. */
-		BMO_slot_map_ptr_insert(op, op->slots_out, "boundarymap.out",
+		BMO_slot_map_ptr_insert(op, slot_boundarymap_out,
 		                        source_edge, target_edge);
 	}
 
@@ -124,7 +126,9 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
  * Copy an existing face from one bmesh to another.
  */
 
-static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
+static BMFace *copy_face(BMOperator *op,
+                         BMOpSlot *slot_facemap_out,
+                         BMesh *source_mesh,
                          BMFace *source_face, BMesh *target_mesh,
                          BMVert **vtar, BMEdge **edar, GHash *vhash, GHash *ehash)
 {
@@ -151,11 +155,11 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
 		vtar[i] = BLI_ghash_lookup(vhash, source_loop->v);
 		edar[i] = BLI_ghash_lookup(ehash, source_loop->e);
 	}
-	
+
 	/* create new face */
 	target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, FALSE);
-	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", source_face, target_face);
-	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", target_face, source_face);
+	BMO_slot_map_ptr_insert(op, slot_facemap_out, source_face, target_face);
+	BMO_slot_map_ptr_insert(op, slot_facemap_out, target_face, source_face);
 
 	BM_elem_attrs_copy(source_mesh, target_mesh, source_face, target_face);
 
@@ -181,7 +185,7 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
  * Internal Copy function.
  */
 
-static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
+static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst)
 {
 
 	BMVert *v = NULL, *v2;
@@ -196,22 +200,26 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
 	BMIter viter, eiter, fiter;
 	GHash *vhash, *ehash;
 
+	BMOpSlot *slot_boundarymap_out = BMO_slot_get(op->slots_out, "boundarymap.out");
+	BMOpSlot *slot_facemap_out     = BMO_slot_get(op->slots_out, "facemap.out");
+	BMOpSlot *slot_isovertmap_out  = BMO_slot_get(op->slots_out, "isovertmap.out");
+
 	/* initialize pointer hashes */
 	vhash = BLI_ghash_ptr_new("bmesh dupeops v");
 	ehash = BLI_ghash_ptr_new("bmesh dupeops e");
 
 	/* duplicate flagged vertices */
-	BM_ITER_MESH (v, &viter, source, BM_VERTS_OF_MESH) {
-		if (BMO_elem_flag_test(source, v, DUPE_INPUT) &&
-		    !BMO_elem_flag_test(source, v, DUPE_DONE))
+	BM_ITER_MESH (v, &viter, bm_src, BM_VERTS_OF_MESH) {
+		if (BMO_elem_flag_test(bm_src, v, DUPE_INPUT) &&
+		    !BMO_elem_flag_test(bm_src, v, DUPE_DONE))
 		{
 			BMIter iter;
 			int isolated = 1;
 
-			v2 = copy_vertex(source, v, target, vhash);
+			v2 = copy_vertex(bm_src, v, bm_dst, vhash);
 
 			BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) {
-				if (BMO_elem_flag_test(source, f, DUPE_INPUT)) {
+				if (BMO_elem_flag_test(bm_src, f, DUPE_INPUT)) {
 					isolated = 0;
 					break;
 				}
@@ -219,7 +227,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
 
 			if (isolated) {
 				BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
-					if (BMO_elem_flag_test(source, e, DUPE_INPUT)) {
+					if (BMO_elem_flag_test(bm_src, e, DUPE_INPUT)) {
 						isolated = 0;
 						break;
 					}
@@ -227,49 +235,49 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
 			}
 
 			if (isolated) {
-				BMO_slot_map_ptr_insert(op, op->slots_out, "isovertmap.out", v, v2);
+				BMO_slot_map_ptr_insert(op, slot_isovertmap_out, v, v2);
 			}
 
-			BMO_elem_flag_enable(source, v, DUPE_DONE);
+			BMO_elem_flag_enable(bm_src, v, DUPE_DONE);
 		}
 	}
 
 	/* now we dupe all the edges */
-	BM_ITER_MESH (e, &eiter, source, BM_EDGES_OF_MESH) {
-		if (BMO_elem_flag_test(source, e, DUPE_INPUT) &&
-		    !BMO_elem_flag_test(source, e, DUPE_DONE))
+	BM_ITER_MESH (e, &eiter, bm_src, BM_EDGES_OF_MESH) {
+		if (BMO_elem_flag_test(bm_src, e, DUPE_INPUT) &&
+		    !BMO_elem_flag_test(bm_src, e, DUPE_DONE))
 		{
 			/* make sure that verts are copied */
-			if (!BMO_elem_flag_test(source, e->v1, DUPE_DONE)) {
-				copy_vertex(source, e->v1, target, vhash);
-				BMO_elem_flag_enable(source, e->v1, DUPE_DONE);
+			if (!BMO_elem_flag_test(bm_src, e->v1, DUPE_DONE)) {
+				copy_vertex(bm_src, e->v1, bm_dst, vhash);
+				BMO_elem_flag_enable(bm_src, e->v1, DUPE_DONE);
 			}
-			if (!BMO_elem_flag_test(source, e->v2, DUPE_DONE)) {
-				copy_vertex(source, e->v2, target, vhash);
-				BMO_elem_flag_enable(source, e->v2, DUPE_DONE);
+			if (!BMO_elem_flag_test(bm_src, e->v2, DUPE_DONE)) {
+				copy_vertex(bm_src, e->v2, bm_dst, vhash);
+				BMO_elem_flag_enable(bm_src, e->v2, DUPE_DONE);
 			}
 			/* now copy the actual edge */
-			copy_edge(op, source, e, target, vhash, ehash);
-			BMO_elem_flag_enable(source, e, DUPE_DONE);
+			copy_edge(op, slot_boundarymap_out, bm_src, e, bm_dst, vhash, ehash);
+			BMO_elem_flag_enable(bm_src, e, DUPE_DONE);
 		}
 	}
 
 	/* first we dupe all flagged faces and their elements from source */
-	BM_ITER_MESH (f, &fiter, source, BM_FACES_OF_MESH) {
-		if (BMO_elem_flag_test(source, f, DUPE_INPUT)) {
+	BM_ITER_MESH (f, &fiter, bm_src, BM_FACES_OF_MESH) {
+		if (BMO_elem_flag_test(bm_src, f, DUPE_INPUT)) {
 			/* vertex pass */
 			BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) {
-				if (!BMO_elem_flag_test(source, v, DUPE_DONE)) {
-					copy_vertex(source, v, target, vhash);
-					BMO_elem_flag_enable(source, v, DUPE_DONE);
+				if (!BMO_elem_flag_test(bm_src, v, DUPE_DONE)) {
+					copy_vertex(bm_src, v, bm_dst, vhash);
+					BMO_elem_flag_enable(bm_src, v, DUPE_DONE);
 				}
 			}
 
 			/* edge pass */
 			BM_ITER_ELEM (e, &eiter, f, BM_EDGES_OF_FACE) {
-				if (!BMO_elem_flag_test(source, e, DUPE_DONE)) {
-					copy_edge(op, source, e, target, vhash, ehash);
-					BMO_elem_flag_enable(source, e, DUPE_DONE);
+				if (!BMO_elem_flag_test(bm_src, e, DUPE_DONE)) {
+					copy_edge(op, slot_boundarymap_out, bm_src, e, bm_dst, vhash, ehash);
+					BMO_elem_flag_enable(bm_src, e, DUPE_DONE);
 				}
 			}
 
@@ -280,8 +288,8 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
 			BLI_array_grow_items(vtar, f->len);
 			BLI_array_grow_items(edar, f->len);
 
-			copy_face(op, source, f, target, vtar, edar, vhash, ehash);
-			BMO_elem_flag_enable(source, f, DUPE_DONE);
+			copy_face(op, slot_facemap_out, bm_src, f, bm_dst, vtar, edar, vhash, ehash);
+			BMO_elem_flag_enable(bm_src, f, DUPE_DONE);
 		}
 	}
 	
diff --git a/source/blender/bmesh/operators/bmo_extrude.c b/source/blender/bmesh/operators/bmo_extrude.c
index 9ad0bd2c949..6a9d9c1e48b 100644
--- a/source/blender/bmesh/operators/bmo_extrude.c
+++ b/source/blender/bmesh/operators/bmo_extrude.c
@@ -264,6 +264,8 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 	BMVert *v, *v2;
 	BMFace *f;
 	int found, fwd, delorig = FALSE;
+	BMOpSlot *slot_facemap_out;
+	BMOpSlot *slot_edges_exclude;
 
 	/* initialize our sub-operators */
 	BMO_op_init(bm, &dupeop, op->flag, "duplicate");
@@ -350,8 +352,10 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT))
-		bm->act_face = BMO_slot_map_ptr_get(dupeop.slots_out, "facemap.out", bm->act_face);
+	slot_facemap_out = BMO_slot_get(dupeop.slots_out, "facemap.out");
+	if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT)) {
+		bm->act_face = BMO_slot_map_ptr_get(slot_facemap_out, bm->act_face);
+	}
 
 	if (delorig) {
 		BMO_op_exec(bm, &delop);
@@ -369,11 +373,12 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 	BMO_slot_copy(&dupeop, slots_out, "geom.out",
 	              op,      slots_out, "geom.out");
 
+	slot_edges_exclude = BMO_slot_get(op->slots_in, "edges_exclude");
 	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap.out", 0); e; e = BMO_iter_step(&siter)) {
 		BMVert *f_verts[4];
 
 		/* this should always be wire, so this is mainly a speedup to avoid map lookup */
-		if (BM_edge_is_wire(e) && BMO_slot_map_contains(op->slots_in, "edges_exclude", e)) {
+		if (BM_edge_is_wire(e) && BMO_slot_map_contains(slot_edges_exclude, e)) {
 			BMVert *v1 = e->v1, *v2 = e->v2;
 
 			/* The original edge was excluded,
diff --git a/source/blender/bmesh/operators/bmo_mirror.c b/source/blender/bmesh/operators/bmo_mirror.c
index 8d3385ddfe6..01bce976ec0 100644
--- a/source/blender/bmesh/operators/bmo_mirror.c
+++ b/source/blender/bmesh/operators/bmo_mirror.c
@@ -55,6 +55,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 	int axis = BMO_slot_int_get(op->slots_in, "axis");
 	int mirroru = BMO_slot_bool_get(op->slots_in, "mirror_u");
 	int mirrorv = BMO_slot_bool_get(op->slots_in, "mirror_v");
+	BMOpSlot *slot_targetmap;
 
 	ototvert = bm->totvert;
 	/* ototedge = bm->totedge; */ /* UNUSED */
@@ -86,10 +87,12 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 	
 	BMO_op_init(bm, &weldop, op->flag, "weld_verts");
 
+	slot_targetmap = BMO_slot_get(weldop.slots_in, "targetmap");
+
 	v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
 	for (i = 0; i < ototvert; i++) {
 		if (fabsf(v->co[axis]) <= dist) {
-			BMO_slot_map_ptr_insert(&weldop, weldop.slots_in, "targetmap", vmap[i], v);
+			BMO_slot_map_ptr_insert(&weldop, slot_targetmap, vmap[i], v);
 		}
 		v = BM_iter_step(&iter);
 	}
diff --git a/source/blender/bmesh/operators/bmo_removedoubles.c b/source/blender/bmesh/operators/bmo_removedoubles.c
index e866abcb6dc..7ce69e69be3 100644
--- a/source/blender/bmesh/operators/bmo_removedoubles.c
+++ b/source/blender/bmesh/operators/bmo_removedoubles.c
@@ -36,7 +36,7 @@
 
 #include "intern/bmesh_operators_private.h" /* own include */
 
-static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op)
+static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op, BMOpSlot *slot_targetmap)
 {
 	BMIter liter;
 	BMLoop *l;
@@ -44,7 +44,7 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op)
 	int split = FALSE;
 
 	BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
-		v2 = BMO_slot_map_ptr_get(op->slots_in, "targetmap", l->v);
+		v2 = BMO_slot_map_ptr_get(slot_targetmap, l->v);
 		/* ok: if v2 is NULL (e.g. not in the map) then it's
 		 *     a target vert, otherwise it's a double */
 		if ((v2 && BM_vert_in_face(f, v2)) &&
@@ -61,8 +61,8 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op)
 		BMLoop *nl;
 		BMFace *f2 = BM_face_split(bm, f, doub, v2, &nl, NULL, FALSE);
 
-		remdoubles_splitface(f, bm, op);
-		remdoubles_splitface(f2, bm, op);
+		remdoubles_splitface(f, bm, op, slot_targetmap);
+		remdoubles_splitface(f2, bm, op, slot_targetmap);
 	}
 }
 
@@ -106,10 +106,11 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
 	BLI_array_declare(loops);
 	BMFace *f, *f2;
 	int a, b;
+	BMOpSlot *slot_targetmap = BMO_slot_get(op->slots_in, "targetmap");
 
 	/* mark merge verts for deletion */
 	BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-		if ((v2 = BMO_slot_map_ptr_get(op->slots_in, "targetmap", v))) {
+		if ((v2 = BMO_slot_map_ptr_get(slot_targetmap, v))) {
 			BMO_elem_flag_enable(bm, v, ELE_DEL);
 
 			/* merge the vertex flags, else we get randomly selected/unselected verts */
@@ -120,13 +121,13 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
 	/* check if any faces are getting their own corners merged
 	 * together, split face if so */
 	BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-		remdoubles_splitface(f, bm, op);
+		remdoubles_splitface(f, bm, op, slot_targetmap);
 	}
 
 	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 		if (BMO_elem_flag_test(bm, e->v1, ELE_DEL) || BMO_elem_flag_test(bm, e->v2, ELE_DEL)) {
-			v  = BMO_slot_map_ptr_get(op->slots_in, "targetmap", e->v1);
-			v2 = BMO_slot_map_ptr_get(op->slots_in, "targetmap", e->v2);
+			v  = BMO_slot_map_ptr_get(slot_targetmap, e->v1);
+			v2 = BMO_slot_map_ptr_get(slot_targetmap, e->v2);
 			
 			if (!v) v = e->v1;
 			if (!v2) v2 = e->v2;
@@ -174,10 +175,10 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
 			v = l->v;
 			v2 = l->next->v;
 			if (BMO_elem_flag_test(bm, v, ELE_DEL)) {
-				v = BMO_slot_map_ptr_get(op->slots_in, "targetmap", v);
+				v = BMO_slot_map_ptr_get(slot_targetmap, v);
 			}
 			if (BMO_elem_flag_test(bm, v2, ELE_DEL)) {
-				v2 = BMO_slot_map_ptr_get(op->slots_in, "targetmap", v2);
+				v2 = BMO_slot_map_ptr_get(slot_targetmap, v2);
 			}
 			
 			e2 = v != v2 ? BM_edge_exists(v, v2) : NULL;
@@ -207,10 +208,10 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
 		v2 = loops[1]->v;
 
 		if (BMO_elem_flag_test(bm, v, ELE_DEL)) {
-			v = BMO_slot_map_ptr_get(op->slots_in, "targetmap", v);
+			v = BMO_slot_map_ptr_get(slot_targetmap, v);
 		}
 		if (BMO_elem_flag_test(bm, v2, ELE_DEL)) {
-			v2 = BMO_slot_map_ptr_get(op->slots_in, "targetmap", v2);
+			v2 = BMO_slot_map_ptr_get(slot_targetmap, v2);
 		}
 		
 		f2 = BM_face_create_ngon(bm, v, v2, edges, a, TRUE);
@@ -344,19 +345,22 @@ void bmo_pointmerge_exec(BMesh *bm, BMOperator *op)
 	BMOIter siter;
 	BMVert *v, *snapv = NULL;
 	float vec[3];
+	BMOpSlot *slot_targetmap;
 	
 	BMO_slot_vec_get(op->slots_in, "merge_co", vec);
 
 	//BMO_op_callf(bm, op->flag, "collapse_uvs edges=%s", op, "edges");
 	BMO_op_init(bm, &weldop, op->flag, "weld_verts");
-	
+
+	slot_targetmap = BMO_slot_get(weldop.slots_in, "targetmap");
+
 	BMO_ITER (v, &siter, op->slots_in, "verts", BM_VERT) {
 		if (!snapv) {
 			snapv = v;
 			copy_v3_v3(snapv->co, vec);
 		}
 		else {
-			BMO_slot_map_ptr_insert(&weldop, weldop.slots_in, "targetmap", v, snapv);
+			BMO_slot_map_ptr_insert(&weldop, slot_targetmap, v, snapv);
 		}
 	}
 
@@ -373,9 +377,11 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op)
 	BLI_array_declare(edges);
 	float min[3], max[3], center[3];
 	int i, tot;
+	BMOpSlot *slot_targetmap;
 	
 	BMO_op_callf(bm, op->flag, "collapse_uvs edges=%s", op, "edges");
 	BMO_op_init(bm, &weldop, op->flag, "weld_verts");
+	slot_targetmap = BMO_slot_get(weldop.slots_in, "targetmap");
 
 	BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, EDGE_MARK);
 
@@ -408,9 +414,9 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op)
 			copy_v3_v3(edges[i]->v2->co, center);
 			
 			if (edges[i]->v1 != edges[0]->v1)
-				BMO_slot_map_ptr_insert(&weldop, weldop.slots_in, "targetmap", edges[i]->v1, edges[0]->v1);
+				BMO_slot_map_ptr_insert(&weldop, slot_targetmap, edges[i]->v1, edges[0]->v1);
 			if (edges[i]->v2 != edges[0]->v1)
-				BMO_slot_map_ptr_insert(&weldop, weldop.slots_in, "targetmap", edges[i]->v2, edges[0]->v1);
+				BMO_slot_map_ptr_insert(&weldop, slot_targetmap, edges[i]->v2, edges[0]->v1);
 		}
 	}
 	
@@ -487,9 +493,7 @@ void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op)
 }
 
 static void bmesh_find_doubles_common(BMesh *bm, BMOperator *op,
-                                      BMOperator *optarget,
-                                      BMOpSlot optarget_slot_args[BMO_OP_MAX_SLOTS],
-                                      const char *targetmapname)
+                                      BMOperator *optarget, BMOpSlot *optarget_slot)
 {
 	BMVert  **verts;
 	int       verts_len;
@@ -550,7 +554,7 @@ static void bmesh_find_doubles_common(BMesh *bm, BMOperator *op,
 				BMO_elem_flag_enable(bm, v_other, VERT_DOUBLE);
 				BMO_elem_flag_enable(bm, v_check, VERT_TARGET);
 
-				BMO_slot_map_ptr_insert(optarget, optarget_slot_args, targetmapname, v_other, v_check);
+				BMO_slot_map_ptr_insert(optarget, optarget_slot, v_other, v_check);
 			}
 		}
 	}
@@ -561,10 +565,12 @@ static void bmesh_find_doubles_common(BMesh *bm, BMOperator *op,
 void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 {
 	BMOperator weldop;
+	BMOpSlot *slot_targetmap;
 
 	BMO_op_init(bm, &weldop, op->flag, "weld_verts");
+	slot_targetmap = BMO_slot_get(weldop.slots_in, "targetmap");
 	bmesh_find_doubles_common(bm, op,
-	                          &weldop, weldop.slots_in, "targetmap");
+	                          &weldop, slot_targetmap);
 	BMO_op_exec(bm, &weldop);
 	BMO_op_finish(bm, &weldop);
 }
@@ -572,8 +578,10 @@ void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 
 void bmo_find_doubles_exec(BMesh *bm, BMOperator *op)
 {
+	BMOpSlot *slot_targetmap_out;
+	slot_targetmap_out = BMO_slot_get(op->slots_out, "targetmap");
 	bmesh_find_doubles_common(bm, op,
-	                          op, op->slots_out, "targetmap.out");
+	                          op, slot_targetmap_out);
 }
 
 void bmo_automerge_exec(BMesh *bm, BMOperator *op)
diff --git a/source/blender/bmesh/operators/bmo_subdivide.c b/source/blender/bmesh/operators/bmo_subdivide.c
index 5032545af89..f9b6611c88b 100644
--- a/source/blender/bmesh/operators/bmo_subdivide.c
+++ b/source/blender/bmesh/operators/bmo_subdivide.c
@@ -225,8 +225,9 @@ static BMVert *subdivideedgenum(BMesh *bm, BMEdge *edge, BMEdge *oedge,
 	BMVert *ev;
 	float percent, percent2 = 0.0f;
 
-	if (BMO_elem_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1)
-		percent = BMO_slot_map_float_get(params->op->slots_in, "edgepercents", edge);
+	if (BMO_elem_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1) {
+		percent = BMO_slot_map_float_get(params->slot_edgepercents, edge);
+	}
 	else {
 		percent = 1.0f / (float)(totpoint + 1 - curpoint);
 		percent2 = (float)(curpoint + 1) / (float)(totpoint + 1);
@@ -778,6 +779,8 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 
 	params.numcuts = numcuts;
 	params.op = op;
+	params.slot_edgepercents   = BMO_slot_get(op->slots_in, "edgepercents");
+	params.slot_custompatterns = BMO_slot_get(op->slots_in, "custompatterns");
 	params.smooth = smooth;
 	params.seed = seed;
 	params.fractal = fractal;
@@ -837,7 +840,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 		}
 
 		if (BMO_elem_flag_test(bm, face, FACE_CUSTOMFILL)) {
-			pat = BMO_slot_map_data_get(op->slots_in, "custompatterns", face);
+			pat = BMO_slot_map_data_get(params.slot_custompatterns, face);
 			for (i = 0; i < pat->len; i++) {
 				matched = 1;
 				for (j = 0; j < pat->len; j++) {
@@ -1159,6 +1162,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
 	
 	params.numcuts = BMO_slot_int_get(op->slots_in, "cuts");
 	params.op = op;
+	params.slot_edgepercents = BMO_slot_get(op->slots_in, "edgepercents");
 	
 	BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY);
 	skey = CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY) - 1;
diff --git a/source/blender/bmesh/operators/bmo_subdivide.h b/source/blender/bmesh/operators/bmo_subdivide.h
index d4b926b9275..d0676508917 100644
--- a/source/blender/bmesh/operators/bmo_subdivide.h
+++ b/source/blender/bmesh/operators/bmo_subdivide.h
@@ -39,6 +39,8 @@ typedef struct SubDParams {
 	int seed;
 	int origkey; /* shapekey holding displaced vertex coordinates for current geometry */
 	BMOperator *op;
+	BMOpSlot *slot_edgepercents;  /* BMO_slot_get(params->op->slots_in, "edgepercents"); */
+	BMOpSlot *slot_custompatterns;  /* BMO_slot_get(params->op->slots_in, "custompatterns"); */
 	float off[3];
 } SubDParams;
 
diff --git a/source/blender/bmesh/operators/bmo_triangulate.c b/source/blender/bmesh/operators/bmo_triangulate.c
index 324c95a0ff7..775fa0cb60d 100644
--- a/source/blender/bmesh/operators/bmo_triangulate.c
+++ b/source/blender/bmesh/operators/bmo_triangulate.c
@@ -53,6 +53,7 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
 	BLI_array_declare(projectverts);
 	int i;
 	const int use_beauty = BMO_slot_bool_get(op->slots_in, "use_beauty");
+	BMOpSlot *slot_facemap_out = BMO_slot_get(op->slots_out, "facemap.out");
 
 	for (face = BMO_iter_new(&siter, op->slots_in, "faces", BM_FACE); face; face = BMO_iter_step(&siter)) {
 
@@ -64,9 +65,9 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
 
 		BM_face_triangulate(bm, face, projectverts, EDGE_NEW, FACE_NEW, newfaces, use_beauty);
 
-		BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", face, face);
+		BMO_slot_map_ptr_insert(op, slot_facemap_out, face, face);
 		for (i = 0; newfaces[i]; i++) {
-			BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", newfaces[i], face);
+			BMO_slot_map_ptr_insert(op, slot_facemap_out, newfaces[i], face);
 		}
 	}