Blender  V3.3
bmesh_delete.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2007 Blender Foundation. All rights reserved. */
3 
10 #include "BLI_utildefines.h"
11 
12 #include "bmesh.h"
13 #include "intern/bmesh_private.h"
14 
15 /* BMO functions */
16 
17 /* -------------------------------------------------------------------- */
25 static void bmo_remove_tagged_faces(BMesh *bm, const short oflag)
26 {
27  BMFace *f, *f_next;
28  BMIter iter;
29 
30  BM_ITER_MESH_MUTABLE (f, f_next, &iter, bm, BM_FACES_OF_MESH) {
31  if (BMO_face_flag_test(bm, f, oflag)) {
32  BM_face_kill(bm, f);
33  }
34  }
35 }
36 
37 static void bmo_remove_tagged_edges(BMesh *bm, const short oflag)
38 {
39  BMEdge *e, *e_next;
40  BMIter iter;
41 
42  BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) {
43  if (BMO_edge_flag_test(bm, e, oflag)) {
44  BM_edge_kill(bm, e);
45  }
46  }
47 }
48 
49 static void bmo_remove_tagged_verts(BMesh *bm, const short oflag)
50 {
51  BMVert *v, *v_next;
52  BMIter iter;
53 
54  BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
55  if (BMO_vert_flag_test(bm, v, oflag)) {
56  BM_vert_kill(bm, v);
57  }
58  }
59 }
60 
61 static void bmo_remove_tagged_verts_loose(BMesh *bm, const short oflag)
62 {
63  BMVert *v, *v_next;
64  BMIter iter;
65 
66  BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
67  if (BMO_vert_flag_test(bm, v, oflag) && (v->e == NULL)) {
68  BM_vert_kill(bm, v);
69  }
70  }
71 }
72 
73 void BMO_mesh_delete_oflag_tagged(BMesh *bm, const short oflag, const char htype)
74 {
75  if (htype & BM_FACE) {
77  }
78  if (htype & BM_EDGE) {
80  }
81  if (htype & BM_VERT) {
83  }
84 }
85 
86 void BMO_mesh_delete_oflag_context(BMesh *bm, const short oflag, const int type)
87 {
88  BMEdge *e;
89  BMFace *f;
90 
91  BMIter eiter;
92  BMIter fiter;
93 
94  switch (type) {
95  case DEL_VERTS: {
97 
98  break;
99  }
100  case DEL_EDGES: {
101  /* flush down to vert */
102  BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
103  if (BMO_edge_flag_test(bm, e, oflag)) {
106  }
107  }
110 
111  break;
112  }
113  case DEL_EDGESFACES: {
115 
116  break;
117  }
118  case DEL_ONLYFACES: {
120 
121  break;
122  }
123  case DEL_ONLYTAGGED: {
125 
126  break;
127  }
128  case DEL_FACES:
130  /* go through and mark all edges and all verts of all faces for delete */
131  BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
132  if (BMO_face_flag_test(bm, f, oflag)) {
133  BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
134  BMLoop *l_iter;
135 
136  l_iter = l_first;
137  do {
138  BMO_vert_flag_enable(bm, l_iter->v, oflag);
139  BMO_edge_flag_enable(bm, l_iter->e, oflag);
140  } while ((l_iter = l_iter->next) != l_first);
141  }
142  }
143  /* now go through and mark all remaining faces all edges for keeping */
144  BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
145  if (!BMO_face_flag_test(bm, f, oflag)) {
146  BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
147  BMLoop *l_iter;
148 
149  l_iter = l_first;
150  do {
151  BMO_vert_flag_disable(bm, l_iter->v, oflag);
152  BMO_edge_flag_disable(bm, l_iter->e, oflag);
153  } while ((l_iter = l_iter->next) != l_first);
154  }
155  }
156  /* also mark all the vertices of remaining edges for keeping */
157  BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
158 
159  /* Only exception to normal 'DEL_FACES' logic. */
160  if (type == DEL_FACES_KEEP_BOUNDARY) {
161  if (BM_edge_is_boundary(e)) {
163  }
164  }
165 
166  if (!BMO_edge_flag_test(bm, e, oflag)) {
169  }
170  }
171 
172  /* now delete marked face */
174  /* delete marked edge */
176  /* remove loose vertices */
178 
179  break;
180  }
181  }
182 }
183 
186 /* BM functions
187  *
188  * NOTE: this is just a duplicate of the code above (bad!)
189  * but for now keep in sync, its less hassle than having to create bmesh operator flags,
190  * each time we need to remove some geometry.
191  */
192 
193 /* -------------------------------------------------------------------- */
197 static void bm_remove_tagged_faces(BMesh *bm, const char hflag)
198 {
199  BMFace *f, *f_next;
200  BMIter iter;
201 
202  BM_ITER_MESH_MUTABLE (f, f_next, &iter, bm, BM_FACES_OF_MESH) {
203  if (BM_elem_flag_test(f, hflag)) {
204  BM_face_kill(bm, f);
205  }
206  }
207 }
208 
209 static void bm_remove_tagged_edges(BMesh *bm, const char hflag)
210 {
211  BMEdge *e, *e_next;
212  BMIter iter;
213 
214  BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) {
215  if (BM_elem_flag_test(e, hflag)) {
216  BM_edge_kill(bm, e);
217  }
218  }
219 }
220 
221 static void bm_remove_tagged_verts(BMesh *bm, const char hflag)
222 {
223  BMVert *v, *v_next;
224  BMIter iter;
225 
226  BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
227  if (BM_elem_flag_test(v, hflag)) {
228  BM_vert_kill(bm, v);
229  }
230  }
231 }
232 
233 static void bm_remove_tagged_verts_loose(BMesh *bm, const char hflag)
234 {
235  BMVert *v, *v_next;
236  BMIter iter;
237 
238  BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
239  if (BM_elem_flag_test(v, hflag) && (v->e == NULL)) {
240  BM_vert_kill(bm, v);
241  }
242  }
243 }
244 
245 void BM_mesh_delete_hflag_tagged(BMesh *bm, const char hflag, const char htype)
246 {
247  if (htype & BM_FACE) {
248  bm_remove_tagged_faces(bm, hflag);
249  }
250  if (htype & BM_EDGE) {
251  bm_remove_tagged_edges(bm, hflag);
252  }
253  if (htype & BM_VERT) {
254  bm_remove_tagged_verts(bm, hflag);
255  }
256 }
257 
258 void BM_mesh_delete_hflag_context(BMesh *bm, const char hflag, const int type)
259 {
260  BMEdge *e;
261  BMFace *f;
262 
263  BMIter eiter;
264  BMIter fiter;
265 
266  switch (type) {
267  case DEL_VERTS: {
268  bm_remove_tagged_verts(bm, hflag);
269 
270  break;
271  }
272  case DEL_EDGES: {
273  /* flush down to vert */
274  BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
275  if (BM_elem_flag_test(e, hflag)) {
276  BM_elem_flag_enable(e->v1, hflag);
277  BM_elem_flag_enable(e->v2, hflag);
278  }
279  }
280  bm_remove_tagged_edges(bm, hflag);
282 
283  break;
284  }
285  case DEL_EDGESFACES: {
286  bm_remove_tagged_edges(bm, hflag);
287 
288  break;
289  }
290  case DEL_ONLYFACES: {
291  bm_remove_tagged_faces(bm, hflag);
292 
293  break;
294  }
295  case DEL_ONLYTAGGED: {
297 
298  break;
299  }
300  case DEL_FACES: {
301  /* go through and mark all edges and all verts of all faces for delete */
302  BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
303  if (BM_elem_flag_test(f, hflag)) {
304  BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
305  BMLoop *l_iter;
306 
307  l_iter = l_first;
308  do {
309  BM_elem_flag_enable(l_iter->v, hflag);
310  BM_elem_flag_enable(l_iter->e, hflag);
311  } while ((l_iter = l_iter->next) != l_first);
312  }
313  }
314  /* now go through and mark all remaining faces all edges for keeping */
315  BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
316  if (!BM_elem_flag_test(f, hflag)) {
317  BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
318  BMLoop *l_iter;
319 
320  l_iter = l_first;
321  do {
322  BM_elem_flag_disable(l_iter->v, hflag);
323  BM_elem_flag_disable(l_iter->e, hflag);
324  } while ((l_iter = l_iter->next) != l_first);
325  }
326  }
327  /* also mark all the vertices of remaining edges for keeping */
328  BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
329  if (!BM_elem_flag_test(e, hflag)) {
330  BM_elem_flag_disable(e->v1, hflag);
331  BM_elem_flag_disable(e->v2, hflag);
332  }
333  }
334  /* now delete marked face */
335  bm_remove_tagged_faces(bm, hflag);
336  /* delete marked edge */
337  bm_remove_tagged_edges(bm, hflag);
338  /* remove loose vertices */
339  bm_remove_tagged_verts(bm, hflag);
340 
341  break;
342  }
343  }
344 }
345 
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
#define BM_ALL_NOLOOP
Definition: bmesh_class.h:411
#define BM_FACE_FIRST_LOOP(p)
Definition: bmesh_class.h:622
@ BM_FACE
Definition: bmesh_class.h:386
@ BM_VERT
Definition: bmesh_class.h:383
@ BM_EDGE
Definition: bmesh_class.h:384
void BM_vert_kill(BMesh *bm, BMVert *v)
Definition: bmesh_core.c:939
void BM_face_kill(BMesh *bm, BMFace *f)
Definition: bmesh_core.c:828
void BM_edge_kill(BMesh *bm, BMEdge *e)
Definition: bmesh_core.c:927
static void bm_remove_tagged_verts(BMesh *bm, const char hflag)
Definition: bmesh_delete.c:221
static void bmo_remove_tagged_edges(BMesh *bm, const short oflag)
Definition: bmesh_delete.c:37
static void bm_remove_tagged_edges(BMesh *bm, const char hflag)
Definition: bmesh_delete.c:209
void BMO_mesh_delete_oflag_tagged(BMesh *bm, const short oflag, const char htype)
Definition: bmesh_delete.c:73
void BM_mesh_delete_hflag_context(BMesh *bm, const char hflag, const int type)
Definition: bmesh_delete.c:258
void BM_mesh_delete_hflag_tagged(BMesh *bm, const char hflag, const char htype)
Definition: bmesh_delete.c:245
static void bm_remove_tagged_verts_loose(BMesh *bm, const char hflag)
Definition: bmesh_delete.c:233
static void bmo_remove_tagged_faces(BMesh *bm, const short oflag)
Definition: bmesh_delete.c:25
static void bmo_remove_tagged_verts(BMesh *bm, const short oflag)
Definition: bmesh_delete.c:49
static void bm_remove_tagged_faces(BMesh *bm, const char hflag)
Definition: bmesh_delete.c:197
void BMO_mesh_delete_oflag_context(BMesh *bm, const short oflag, const int type)
Definition: bmesh_delete.c:86
static void bmo_remove_tagged_verts_loose(BMesh *bm, const short oflag)
Definition: bmesh_delete.c:61
#define BM_elem_flag_disable(ele, hflag)
Definition: bmesh_inline.h:15
#define BM_elem_flag_test(ele, hflag)
Definition: bmesh_inline.h:12
#define BM_elem_flag_enable(ele, hflag)
Definition: bmesh_inline.h:14
#define BM_ITER_MESH(ele, iter, bm, itype)
@ BM_EDGES_OF_MESH
@ BM_VERTS_OF_MESH
@ BM_FACES_OF_MESH
#define BM_ITER_MESH_MUTABLE(ele, ele_next, iter, bm, itype)
ATTR_WARN_UNUSED_RESULT BMesh * bm
#define BMO_vert_flag_disable(bm, e, oflag)
#define BMO_edge_flag_test(bm, e, oflag)
#define BMO_edge_flag_enable(bm, e, oflag)
@ DEL_ONLYTAGGED
@ DEL_FACES_KEEP_BOUNDARY
@ DEL_EDGESFACES
@ DEL_EDGES
@ DEL_FACES
@ DEL_ONLYFACES
@ DEL_VERTS
#define BMO_vert_flag_enable(bm, e, oflag)
#define BMO_vert_flag_test(bm, e, oflag)
#define BMO_edge_flag_disable(bm, e, oflag)
#define BMO_face_flag_test(bm, e, oflag)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMVert * v
struct BMVert * v
Definition: bmesh_class.h:153
struct BMEdge * e
Definition: bmesh_class.h:164
struct BMLoop * next
Definition: bmesh_class.h:233
struct BMEdge * e
Definition: bmesh_class.h:97