[Bf-blender-cvs] [b6a822d7262] blender2.8: Multi-Object-Editing: Weld Edges into Faces(MESH_OT_face_split_by_edges)

milios noreply at git.blender.org
Wed May 16 11:55:51 CEST 2018


Commit: b6a822d72623d12efd51bd9444710857f3a45159
Author: milios
Date:   Wed May 16 11:48:34 2018 +0200
Branches: blender2.8
https://developer.blender.org/rBb6a822d72623d12efd51bd9444710857f3a45159

Multi-Object-Editing: Weld Edges into Faces(MESH_OT_face_split_by_edges)

Reviewers: dfelinto

Maniphest Tasks: T54643

Differential Revision: https://developer.blender.org/D3308

===================================================================

M	source/blender/editors/mesh/editmesh_intersect.c

===================================================================

diff --git a/source/blender/editors/mesh/editmesh_intersect.c b/source/blender/editors/mesh/editmesh_intersect.c
index d681d904e74..fb1e02bedb5 100644
--- a/source/blender/editors/mesh/editmesh_intersect.c
+++ b/source/blender/editors/mesh/editmesh_intersect.c
@@ -33,6 +33,7 @@
 #include "BLI_kdopbvh.h"
 #include "BLI_linklist_stack.h"
 
+#include "BKE_layer.h"
 #include "BKE_editmesh_bvh.h"
 #include "BKE_context.h"
 #include "BKE_report.h"
@@ -652,257 +653,270 @@ static BMEdge *bm_face_split_edge_find(
 
 static int edbm_face_split_by_edges_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	Object *obedit = CTX_data_edit_object(C);
-	BMEditMesh *em = BKE_editmesh_from_object(obedit);
-	BMesh *bm = em->bm;
 	const char hflag = BM_ELEM_TAG;
 
 	BMEdge *e;
 	BMIter iter;
 
-	BLI_SMALLSTACK_DECLARE(loop_stack, BMLoop *);
+	ViewLayer *view_layer = CTX_data_view_layer(C);
+	uint objects_len = 0;
+	Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
+	for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
+		Object *obedit = objects[ob_index];
+		BMEditMesh *em = BKE_editmesh_from_object(obedit);
+		BMesh *bm = em->bm;
 
-	{
-		BMVert *v;
-		BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-			BM_elem_flag_disable(v, hflag);
+		if ((bm->totedgesel == 0) ||
+		    (bm->totfacesel == 0))
+		{
+			continue;
 		}
-	}
-
-	/* edge index is set to -1 then used to assosiate them with faces */
-	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-		if (BM_elem_flag_test(e, BM_ELEM_SELECT) && BM_edge_is_wire(e)) {
-			BM_elem_flag_enable(e, hflag);
 
-			BM_elem_flag_enable(e->v1, hflag);
-			BM_elem_flag_enable(e->v2, hflag);
+		BLI_SMALLSTACK_DECLARE(loop_stack, BMLoop *);
 
+		{
+			BMVert *v;
+			BM_ITER_MESH(v, &iter, bm, BM_VERTS_OF_MESH) {
+				BM_elem_flag_disable(v, hflag);
+			}
 		}
-		else {
-			BM_elem_flag_disable(e, hflag);
-		}
-		BM_elem_index_set(e, -1);  /* set_dirty */
-	}
-	bm->elem_index_dirty |= BM_EDGE;
 
-	{
-		BMFace *f;
-		int i;
-		BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, i) {
-			if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
-				BM_elem_flag_enable(f, hflag);
+		/* edge index is set to -1 then used to assosiate them with faces */
+		BM_ITER_MESH(e, &iter, bm, BM_EDGES_OF_MESH) {
+			if (BM_elem_flag_test(e, BM_ELEM_SELECT) && BM_edge_is_wire(e)) {
+				BM_elem_flag_enable(e, hflag);
+
+				BM_elem_flag_enable(e->v1, hflag);
+				BM_elem_flag_enable(e->v2, hflag);
+
 			}
 			else {
-				BM_elem_flag_disable(f, hflag);
+				BM_elem_flag_disable(e, hflag);
 			}
-			BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
-			BM_elem_index_set(f, i);  /* set_ok */
+			BM_elem_index_set(e, -1);  /* set_dirty */
 		}
-	}
-	bm->elem_index_dirty &= ~BM_FACE;
-
-	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-		if (BM_elem_flag_test(e, hflag)) {
-			BMIter viter;
-			BMVert *v;
-			BM_ITER_ELEM (v, &viter, e, BM_VERTS_OF_EDGE) {
-				BMIter liter;
-				BMLoop *l;
-
-				unsigned int loop_stack_len;
-				BMLoop *l_best = NULL;
-
-				BLI_assert(BLI_SMALLSTACK_IS_EMPTY(loop_stack));
-				loop_stack_len = 0;
-
-				BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
-					if (BM_elem_flag_test(l->f, hflag)) {
-						BLI_SMALLSTACK_PUSH(loop_stack, l);
-						loop_stack_len++;
-					}
-				}
+		bm->elem_index_dirty |= BM_EDGE;
 
-				if (loop_stack_len == 0) {
-					/* pass */
-				}
-				else if (loop_stack_len == 1) {
-					l_best = BLI_SMALLSTACK_POP(loop_stack);
+		{
+			BMFace *f;
+			int i;
+			BM_ITER_MESH_INDEX(f, &iter, bm, BM_FACES_OF_MESH, i) {
+				if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
+					BM_elem_flag_enable(f, hflag);
 				}
 				else {
-					/* complicated case, match the edge with a face-loop */
+					BM_elem_flag_disable(f, hflag);
+				}
+				BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
+				BM_elem_index_set(f, i);  /* set_ok */
+			}
+		}
+		bm->elem_index_dirty &= ~BM_FACE;
+
+		BM_ITER_MESH(e, &iter, bm, BM_EDGES_OF_MESH) {
+			if (BM_elem_flag_test(e, hflag)) {
+				BMIter viter;
+				BMVert *v;
+				BM_ITER_ELEM(v, &viter, e, BM_VERTS_OF_EDGE) {
+					BMIter liter;
+					BMLoop *l;
+
+					unsigned int loop_stack_len;
+					BMLoop *l_best = NULL;
+
+					BLI_assert(BLI_SMALLSTACK_IS_EMPTY(loop_stack));
+					loop_stack_len = 0;
+
+					BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
+						if (BM_elem_flag_test(l->f, hflag)) {
+							BLI_SMALLSTACK_PUSH(loop_stack, l);
+							loop_stack_len++;
+						}
+					}
 
-					BMVert *v_other = BM_edge_other_vert(e, v);
-					float e_dir[3];
+					if (loop_stack_len == 0) {
+						/* pass */
+					}
+					else if (loop_stack_len == 1) {
+						l_best = BLI_SMALLSTACK_POP(loop_stack);
+					}
+					else {
+						/* complicated case, match the edge with a face-loop */
+
+						BMVert *v_other = BM_edge_other_vert(e, v);
+						float e_dir[3];
 
-					/* we want closest to zero */
-					float dot_best = FLT_MAX;
+						/* we want closest to zero */
+						float dot_best = FLT_MAX;
 
-					sub_v3_v3v3(e_dir, v_other->co, v->co);
-					normalize_v3(e_dir);
+						sub_v3_v3v3(e_dir, v_other->co, v->co);
+						normalize_v3(e_dir);
 
-					while ((l = BLI_SMALLSTACK_POP(loop_stack))) {
-						float dot_test;
+						while ((l = BLI_SMALLSTACK_POP(loop_stack))) {
+							float dot_test;
 
-						/* Check dot first to save on expensive angle-comparison.
-						 * ideal case is 90d difference == 0.0 dot */
-						dot_test = fabsf(dot_v3v3(e_dir, l->f->no));
-						if (dot_test < dot_best) {
+							/* Check dot first to save on expensive angle-comparison.
+							 * ideal case is 90d difference == 0.0 dot */
+							dot_test = fabsf(dot_v3v3(e_dir, l->f->no));
+							if (dot_test < dot_best) {
 
-							/* check we're in the correct corner (works with convex loops too) */
-							if (angle_signed_on_axis_v3v3v3_v3(l->prev->v->co, l->v->co, v_other->co,    l->f->no) <
-							    angle_signed_on_axis_v3v3v3_v3(l->prev->v->co, l->v->co, l->next->v->co, l->f->no))
-							{
-								dot_best = dot_test;
-								l_best = l;
+								/* check we're in the correct corner (works with convex loops too) */
+								if (angle_signed_on_axis_v3v3v3_v3(l->prev->v->co, l->v->co, v_other->co, l->f->no) <
+									angle_signed_on_axis_v3v3v3_v3(l->prev->v->co, l->v->co, l->next->v->co, l->f->no))
+								{
+									dot_best = dot_test;
+									l_best = l;
+								}
 							}
 						}
 					}
-				}
 
-				if (l_best) {
-					BM_elem_index_set(e, BM_elem_index_get(l_best->f));  /* set_dirty */
+					if (l_best) {
+						BM_elem_index_set(e, BM_elem_index_get(l_best->f));  /* set_dirty */
+					}
 				}
 			}
 		}
-	}
 
-	{
-		BMFace *f;
-		BLI_buffer_declare_static(BMEdge **, edge_net_temp_buf, 0, 128);
+		{
+			BMFace *f;
+			BLI_buffer_declare_static(BMEdge **, edge_net_temp_buf, 0, 128);
 
-		BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-			if (BM_elem_flag_test(f, hflag)) {
-				bm_face_split_by_edges(bm, f, hflag, &edge_net_temp_buf);
+			BM_ITER_MESH(f, &iter, bm, BM_FACES_OF_MESH) {
+				if (BM_elem_flag_test(f, hflag)) {
+					bm_face_split_by_edges(bm, f, hflag, &edge_net_temp_buf);
+				}
 			}
+			BLI_buffer_free(&edge_net_temp_buf);
 		}
-		BLI_buffer_free(&edge_net_temp_buf);
-	}
 
 #ifdef USE_NET_ISLAND_CONNECT
-	/* before overwriting edge index values, collect edges left untouched */
-	BLI_Stack *edges_loose = BLI_stack_new(sizeof(BMEdge * ), __func__);
-	BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-		if (BM_elem_flag_test(e, BM_ELEM_SELECT) && BM_edge_is_wire(e)) {
-			BLI_stack_push(edges_loose, &e);
+		/* before overwriting edge index values, collect edges left untouched */
+		BLI_Stack *edges_loose = BLI_stack_new(sizeof(BMEdge *), __func__);
+		BM_ITER_MESH(e, &iter, bm, BM_EDGES_OF_MESH) {
+			if (BM_elem_flag_test(e, BM_ELEM_SELECT) && BM_edge_is_wire(e)) {
+				BLI_stack_push(edges_loose, &e);
+			}
 		}
-	}
 #endif
 
-	EDBM_mesh_normals_update(em);
-	EDBM_update_generic(em, true, true);
+		EDBM_mesh_normals_update(em);
+		EDBM_update_generic(em, true, true);
 
 
 #ifdef USE_NET_ISLAND_CONNECT
-	/* we may have remaining isolated regions remaining,
-	 * these will need to have connecting edges created */
-	if (!BLI_stack_is_empty(edges_loose)) {
-		GHash *face_edge_map = BLI_ghash_ptr_new(__func__);
+		/* we may have remaining isolated regions remaining,
+		 * these will need to have connecting edges created */
+		if (!BLI_stack_is_empty(edges_loose)) {
+			GHash *face_edge_map = BLI_ghash_ptr_new(__func__);
 
-		MemArena *mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
+			MemArena *mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
 
-		BM_mesh_elem_index_ensure(bm, BM_FACE);
+			BM_mesh_elem_index_ensure(bm, BM_FACE);
 
-		{
-			BMBVHTree *bmbvh = BKE_bmbvh_new(bm, em->looptris, em->tottri, BMBVH_RESPECT_SELECT, NULL, false);
+			{
+				BMBVHTree *bmbvh = BKE_bmbvh_new(bm, em->looptris, em->tottri, BMBVH_RESPECT_SELECT, NULL, false);
 
-			BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-				BM_elem_index_set(e, -1);  /* set_dirty */
-			}
+				BM_ITER_MESH(e, &iter, bm, BM_EDGES_OF_MESH) {
+					BM_elem_index_set(e, -1);  /* set_dirty */
+				}
 
-			while (!BLI_stack_is_empty(edges_loose)) {
-				BLI_stack_pop(edges_loose, &e);
-				float e_center[3];
-				mid_v3_v3v3(e_center, e->v1->co, e->v2->co);
+				while (!BLI_stack_is_empty(edges_loose)) {
+					BLI_stack_pop(edges_loose, &e);
+					float e_center[3];
+					mid_v3_v3v3(e_center, e->v1->co, e->v2->co);
 
-				BMFace *f = BKE_bmbvh_find_face_closest(bmbvh, e_center, FLT_MAX);
-				if (f) {
-					ghash_insert_face_edge_link(face_edge_map, f, e, mem_arena);
-					BM_elem_index_set(e, BM_elem_index_get(f));  /* set_dirty */
+					BMFace *f = BKE_bmbvh_find_face_closest(bmbvh, e_center, FLT_MAX);
+					if (f) {
+						ghash_insert_face_edge_link(face_edge_map, f, e, mem_arena);
+						BM_elem_index_set(e, BM_elem_index_get(f));  /* set_dirty */
+					}
 				}
-			}
 
-			BKE_bmbvh_free(bmbvh);
-		}
+				BKE_bmbvh_free(bmbvh);
+			}
 
-		bm->elem_index_dirty |= BM_EDGE;
+			bm->elem_index_dirty |= BM_EDGE;
 
-		BM_mesh_elem_table_ensure(bm, BM_FACE);
+			BM_mesh_elem_table_ensure(bm, BM_FACE);
 
-		/* detect edges chai

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list