use input and output slots for bmesh operators, needed for the python api to get return values.

2 files changed, 42 insertions, 27 deletions

diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 8ddae9f3c57..d9526199d16 100644
--- a/source/blender/modifiers/intern/MOD_array.c
+++ b/source/blender/modifiers/intern/MOD_array.c
@@ -178,14 +178,14 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 	             amd->merge_dist, dupe_op, "geom");
 
 	BMO_op_exec(bm, &find_op);
-			
+
 	i = 0;
-	BMO_ITER (ele, &oiter, bm, dupe_op, "geom", BM_ALL) {
+	BMO_ITER (ele, &oiter, dupe_op->slots_in, "geom", BM_ALL) {
 		BM_elem_index_set(ele, i); /* set_dirty */
 		i++;
 	}
 
-	BMO_ITER (ele, &oiter, bm, dupe_op, "newout", BM_ALL) {
+	BMO_ITER (ele, &oiter, dupe_op->slots_out, "newout", BM_ALL) {
 		BM_elem_index_set(ele, i); /* set_dirty */
 		i++;
 	}
@@ -197,7 +197,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 	index_map = MEM_callocN(sizeof(int) * (*index_map_length), "index_map");
 
 	/*element type argument doesn't do anything here*/
-	BMO_ITER (v, &oiter, bm, &find_op, "targetmapout", 0) {
+	BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
 		v2 = BMO_iter_map_value_p(&oiter);
 
 		index_map[BM_elem_index_get(v)] = BM_elem_index_get(v2) + 1;
@@ -218,9 +218,10 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
                                   const ArrayModifierData *amd,
                                   BMOperator *dupe_op,
-                                  const char *dupe_slot_name,
+                                  BMOpSlot dupe_op_slot_args[BMO_OP_MAX_SLOTS], const char *dupe_slot_name,
                                   BMOperator *weld_op)
 {
+	const int is_input = (dupe_op->slots_in == dupe_op_slot_args);
 	BMVert *v, *v2, *v3;
 	BMIter iter;
 
@@ -236,12 +237,24 @@ static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
 		BMOperator find_op;
 
 		BMO_op_initf(bm, &find_op, (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
-		             "find_doubles verts=%Hv dist=%f keep_verts=%s",
+		             is_input ?  /* ugh */
+		             "find_doubles verts=%Hv dist=%f keep_verts=%s" :
+		             "find_doubles verts=%Hv dist=%f keep_verts=%S",
 		             BM_ELEM_TAG, amd->merge_dist,
 		             dupe_op, dupe_slot_name);
 
 		/* append the dupe's geom to the findop input verts */
-		BMO_slot_buffer_append(&find_op, "verts", dupe_op, dupe_slot_name);
+		if (is_input) {
+			BMO_slot_buffer_append(&find_op, slots_in, "verts",
+			                       dupe_op,  slots_in, dupe_slot_name);
+		}
+		else if (dupe_op->slots_out == dupe_op_slot_args) {
+			BMO_slot_buffer_append(&find_op, slots_in,  "verts",
+			                       dupe_op,  slots_out, dupe_slot_name);
+		}
+		else {
+			BLI_assert(0);
+		}
 
 		/* transform and tag verts */
 		BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
@@ -254,14 +267,14 @@ static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
 		BMO_op_exec(bm, &find_op);
 
 		/* add new merge targets to weld operator */
-		BMO_ITER (v, &oiter, bm, &find_op, "targetmapout", 0) {
+		BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
 			v2 = BMO_iter_map_value_p(&oiter);
 			/* check in case the target vertex (v2) is already marked
 			 * for merging */
-			while ((v3 = BMO_slot_map_ptr_get(bm, weld_op, "targetmap", v2))) {
+			while ((v3 = BMO_slot_map_ptr_get(weld_op->slots_in, "targetmap", v2))) {
 				v2 = v3;
 			}
-			BMO_slot_map_ptr_insert(bm, weld_op, "targetmap", v, v2);
+			BMO_slot_map_ptr_insert(weld_op, weld_op->slots_in, "targetmap", v, v2);
 		}
 
 		BMO_op_finish(bm, &find_op);
@@ -293,14 +306,15 @@ static void merge_first_last(BMesh *bm,
 	             dupe_first, "geom");
 
 	/* append the last dupe's geom to the findop input verts */
-	BMO_slot_buffer_append(&find_op, "verts", dupe_last, "newout");
+	BMO_slot_buffer_append(&find_op,  slots_in,  "verts",
+	                       dupe_last, slots_out, "newout");
 
 	BMO_op_exec(bm, &find_op);
 
 	/* add new merge targets to weld operator */
-	BMO_ITER (v, &oiter, bm, &find_op, "targetmapout", 0) {
+	BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
 		v2 = BMO_iter_map_value_p(&oiter);
-		BMO_slot_map_ptr_insert(bm, weld_op, "targetmap", v, v2);
+		BMO_slot_map_ptr_insert(weld_op, weld_op->slots_in, "targetmap", v, v2);
 	}
 
 	BMO_op_finish(bm, &find_op);
@@ -429,12 +443,12 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 		if (j != 0) {
 			BMO_op_initf(bm, &dupe_op,
 			             (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
-			             "duplicate geom=%s", &old_dupe_op, "newout");
+			             "duplicate geom=%S", &old_dupe_op, "newout");
 		}
 		BMO_op_exec(bm, &dupe_op);
 
-		geom_slot = BMO_slot_get(&dupe_op, "geom");
-		newout_slot = BMO_slot_get(&dupe_op, "newout");
+		geom_slot   = BMO_slot_get(dupe_op.slots_in,  "geom");
+		newout_slot = BMO_slot_get(dupe_op.slots_out, "newout");
 
 		if ((amd->flags & MOD_ARR_MERGEFINAL) && j == 0) {
 			int first_geom_bytes = sizeof(BMVert *) * geom_slot->len;
@@ -446,7 +460,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 		}
 
 		/* apply transformation matrix */
-		BMO_ITER (v, &oiter, bm, &dupe_op, "newout", BM_VERT) {
+		BMO_ITER (v, &oiter, dupe_op.slots_out, "newout", BM_VERT) {
 			mul_m4_v3(offset, v->co);
 		}
 
@@ -471,11 +485,11 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 
 				/* check in case the target vertex (v2) is already marked
 				 * for merging */
-				while ((v3 = BMO_slot_map_ptr_get(bm, &weld_op, "targetmap", v2))) {
+				while ((v3 = BMO_slot_map_ptr_get(weld_op.slots_in, "targetmap", v2))) {
 					v2 = v3;
 				}
 
-				BMO_slot_map_ptr_insert(bm, &weld_op, "targetmap", v, v2);
+				BMO_slot_map_ptr_insert(&weld_op, weld_op.slots_in, "targetmap", v, v2);
 			}
 
 			#undef _E
@@ -511,14 +525,15 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 			float startoffset[4][4];
 			invert_m4_m4(startoffset, offset);
 			bm_merge_dm_transform(bm, start_cap, startoffset, amd,
-			                      &first_dupe_op, "geom", &weld_op);
+			                      &first_dupe_op, first_dupe_op.slots_in, "geom", &weld_op);
 		}
 
 		if (end_cap) {
 			float endoffset[4][4];
 			mult_m4_m4m4(endoffset, offset, final_offset);
 			bm_merge_dm_transform(bm, end_cap, endoffset, amd,
-			                      &dupe_op, count == 1 ? "geom" : "newout", &weld_op);
+			                      &dupe_op, (count == 1) ? dupe_op.slots_in : dupe_op.slots_out,
+			                      (count == 1) ? "geom" : "newout", &weld_op);
 		}
 	}
 	/* done capping */
diff --git a/source/blender/modifiers/intern/MOD_skin.c b/source/blender/modifiers/intern/MOD_skin.c
index 96f97a6fa8a..cc2405ed186 100644
--- a/source/blender/modifiers/intern/MOD_skin.c
+++ b/source/blender/modifiers/intern/MOD_skin.c
@@ -249,14 +249,14 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
 	}
 
 	/* Apply face attributes to hull output */
-	BMO_ITER (f, &oiter, bm, &op, "geomout", BM_FACE) {
+	BMO_ITER (f, &oiter, op.slots_out, "geomout", BM_FACE) {
 		if (so->smd->flag & MOD_SKIN_SMOOTH_SHADING)
 			BM_elem_flag_enable(f, BM_ELEM_SMOOTH);
 		f->mat_nr = so->mat_nr;
 	}
 
 	/* Mark interior frames */
-	BMO_ITER (v, &oiter, bm, &op, "interior_geom", BM_VERT) {
+	BMO_ITER (v, &oiter, op.slots_out, "interior_geom_out", BM_VERT) {
 		for (i = 0; i < totframe; i++) {
 			Frame *frame = frames[i];
 			
@@ -309,7 +309,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
 
 	/* Check if removing triangles above will create wire triangles,
 	 * mark them too */
-	BMO_ITER (e, &oiter, bm, &op, "geomout", BM_EDGE) {
+	BMO_ITER (e, &oiter, op.slots_out, "geomout", BM_EDGE) {
 		int is_wire = TRUE;
 		BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
 			if (!BM_elem_flag_test(f, BM_ELEM_TAG)) {
@@ -1090,7 +1090,7 @@ static BMFace *collapse_face_corners(BMesh *bm, BMFace *f, int n,
 		v_safe = shortest_edge->v1;
 		v_merge = shortest_edge->v2;
 		mid_v3_v3v3(v_safe->co, v_safe->co, v_merge->co);
-		BMO_slot_map_ptr_insert(bm, &op, "targetmap", v_merge, v_safe);
+		BMO_slot_map_ptr_insert(&op, op.slots_in, "targetmap", v_merge, v_safe);
 		BMO_op_exec(bm, &op);
 		BMO_op_finish(bm, &op);
 
@@ -1229,7 +1229,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
 	/* Update split face (should only be one new face created
 	 * during extrusion) */
 	split_face = NULL;
-	BMO_ITER (f, &oiter, bm, &op, "faceout", BM_FACE) {
+	BMO_ITER (f, &oiter, op.slots_out, "faceout", BM_FACE) {
 		BLI_assert(!split_face);
 		split_face = f;
 	}
@@ -1282,7 +1282,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
 	BMO_op_init(bm, &op, (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
 	            "weld_verts");
 	for (i = 0; i < 4; i++) {
-		BMO_slot_map_ptr_insert(bm, &op, "targetmap",
+		BMO_slot_map_ptr_insert(&op, op.slots_in, "targetmap",
 		                        verts[i], frame->verts[best_order[i]]);
 	}
 	BMO_op_exec(bm, &op);