Blender V5.3
bmesh_delete.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2007 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include "bmesh.hh"
12
13namespace blender {
14
15/* BMO functions */
16
17/* -------------------------------------------------------------------- */
20
25static 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
37static 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) {
45 }
46 }
47}
48
49static 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) {
57 }
58 }
59}
60
61static 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 == nullptr)) {
69 }
70 }
71}
72
73void 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
87 const short oflag,
88 const int type,
89 FunctionRef<void()> prepare_fn)
90{
91 BMEdge *e;
92
93 BMIter eiter;
94 BMIter fiter;
95
96 switch (type) {
97 case DEL_VERTS: {
98 if (prepare_fn) {
99 prepare_fn();
100 }
102 break;
103 }
104 case DEL_EDGES: {
105 /* flush down to vert */
106 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
107 if (BMO_edge_flag_test(bm, e, oflag)) {
110 }
111 }
112 if (prepare_fn) {
113 prepare_fn();
114 }
117 break;
118 }
119 case DEL_EDGESFACES: {
120 if (prepare_fn) {
121 prepare_fn();
122 }
124 break;
125 }
126 case DEL_ONLYFACES: {
127 if (prepare_fn) {
128 prepare_fn();
129 }
131 break;
132 }
133 case DEL_ONLYTAGGED: {
134 if (prepare_fn) {
135 prepare_fn();
136 }
138 break;
139 }
140 case DEL_FACES:
142 /* go through and mark all edges and all verts of all faces for delete */
143 BMFace *f;
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_enable(bm, l_iter->v, oflag);
152 BMO_edge_flag_enable(bm, l_iter->e, oflag);
153 } while ((l_iter = l_iter->next) != l_first);
154 }
155 }
156 /* now go through and mark all remaining faces all edges for keeping */
157 BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
158 if (!BMO_face_flag_test(bm, f, oflag)) {
159 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
160 BMLoop *l_iter;
161
162 l_iter = l_first;
163 do {
164 BMO_vert_flag_disable(bm, l_iter->v, oflag);
165 BMO_edge_flag_disable(bm, l_iter->e, oflag);
166 } while ((l_iter = l_iter->next) != l_first);
167 }
168 }
169 /* also mark all the vertices of remaining edges for keeping */
170 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
171
172 /* Only exception to normal 'DEL_FACES' logic. */
173 if (type == DEL_FACES_KEEP_BOUNDARY) {
174 if (BM_edge_is_boundary(e)) {
176 }
177 }
178
179 if (!BMO_edge_flag_test(bm, e, oflag)) {
182 }
183 }
184 if (prepare_fn) {
185 prepare_fn();
186 }
187
188 /* now delete marked face */
190 /* delete marked edge */
192 /* remove loose vertices */
194
195 break;
196 }
197 }
198}
199
201
202/* BM functions
203 *
204 * NOTE: this is just a duplicate of the code above (bad!)
205 * but for now keep in sync, its less hassle than having to create bmesh operator flags,
206 * each time we need to remove some geometry.
207 */
208
209/* -------------------------------------------------------------------- */
212
213static void bm_remove_tagged_faces(BMesh *bm, const char hflag)
214{
215 BMFace *f, *f_next;
216 BMIter iter;
217
218 BM_ITER_MESH_MUTABLE (f, f_next, &iter, bm, BM_FACES_OF_MESH) {
219 if (BM_elem_flag_test(f, hflag)) {
220 BM_face_kill(bm, f);
221 }
222 }
223}
224
225static void bm_remove_tagged_edges(BMesh *bm, const char hflag)
226{
227 BMEdge *e, *e_next;
228 BMIter iter;
229
230 BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) {
231 if (BM_elem_flag_test(e, hflag)) {
232 BM_edge_kill(bm, e);
233 }
234 }
235}
236
237static void bm_remove_tagged_verts(BMesh *bm, const char hflag)
238{
239 BMVert *v, *v_next;
240 BMIter iter;
241
242 BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
243 if (BM_elem_flag_test(v, hflag)) {
244 BM_vert_kill(bm, v);
245 }
246 }
247}
248
249static void bm_remove_tagged_verts_loose(BMesh *bm, const char hflag)
250{
251 BMVert *v, *v_next;
252 BMIter iter;
253
254 BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
255 if (BM_elem_flag_test(v, hflag) && (v->e == nullptr)) {
256 BM_vert_kill(bm, v);
257 }
258 }
259}
260
261void BM_mesh_delete_hflag_tagged(BMesh *bm, const char hflag, const char htype)
262{
263 if (htype & BM_FACE) {
265 }
266 if (htype & BM_EDGE) {
268 }
269 if (htype & BM_VERT) {
271 }
272}
273
274void BM_mesh_delete_hflag_context(BMesh *bm, const char hflag, const int type)
275{
276
277 BMIter eiter;
278 BMIter fiter;
279
280 switch (type) {
281 case DEL_VERTS: {
283
284 break;
285 }
286 case DEL_EDGES: {
287 /* flush down to vert */
288 BMEdge *e;
289 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
290 if (BM_elem_flag_test(e, hflag)) {
291 BM_elem_flag_enable(e->v1, hflag);
292 BM_elem_flag_enable(e->v2, hflag);
293 }
294 }
297
298 break;
299 }
300 case DEL_EDGESFACES: {
302
303 break;
304 }
305 case DEL_ONLYFACES: {
307
308 break;
309 }
310 case DEL_ONLYTAGGED: {
312
313 break;
314 }
315 case DEL_FACES: {
316 /* go through and mark all edges and all verts of all faces for delete */
317 BMFace *f;
318 BMEdge *e;
319 BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
320 if (BM_elem_flag_test(f, hflag)) {
321 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
322 BMLoop *l_iter;
323
324 l_iter = l_first;
325 do {
326 BM_elem_flag_enable(l_iter->v, hflag);
327 BM_elem_flag_enable(l_iter->e, hflag);
328 } while ((l_iter = l_iter->next) != l_first);
329 }
330 }
331 /* now go through and mark all remaining faces all edges for keeping */
332 BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
333 if (!BM_elem_flag_test(f, hflag)) {
334 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
335 BMLoop *l_iter;
336
337 l_iter = l_first;
338 do {
339 BM_elem_flag_disable(l_iter->v, hflag);
340 BM_elem_flag_disable(l_iter->e, hflag);
341 } while ((l_iter = l_iter->next) != l_first);
342 }
343 }
344 /* also mark all the vertices of remaining edges for keeping */
345 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
346 if (!BM_elem_flag_test(e, hflag)) {
347 BM_elem_flag_disable(e->v1, hflag);
348 BM_elem_flag_disable(e->v2, hflag);
349 }
350 }
351 /* now delete marked face */
353 /* delete marked edge */
355 /* remove loose vertices */
357
358 break;
359 }
360 }
361}
362
364
365} // namespace blender
#define BM_ALL_NOLOOP
#define BM_FACE_FIRST_LOOP(p)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_MUTABLE(ele, ele_next, iter, bm, itype)
#define BMO_vert_flag_disable(bm, e, oflag)
#define BMO_edge_flag_test(bm, e, oflag)
#define BMO_edge_flag_enable(bm, e, oflag)
#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)
BMesh Iterators.
void BM_mesh_delete_hflag_context(BMesh *bm, const char hflag, const int type)
static void bm_remove_tagged_faces(BMesh *bm, const char hflag)
static void bm_remove_tagged_verts_loose(BMesh *bm, const char hflag)
static void bm_remove_tagged_verts(BMesh *bm, const char hflag)
void BM_vert_kill(BMesh *bm, BMVert *v)
void BMO_mesh_delete_oflag_context(BMesh *bm, const short oflag, const int type, FunctionRef< void()> prepare_fn)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BM_edge_kill(BMesh *bm, BMEdge *e)
static void bmo_remove_tagged_edges(BMesh *bm, const short oflag)
static void bmo_remove_tagged_faces(BMesh *bm, const short oflag)
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BMO_mesh_delete_oflag_tagged(BMesh *bm, const short oflag, const char htype)
void BM_face_kill(BMesh *bm, BMFace *f)
static void bmo_remove_tagged_verts(BMesh *bm, const short oflag)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
static void bm_remove_tagged_edges(BMesh *bm, const char hflag)
static void bmo_remove_tagged_verts_loose(BMesh *bm, const short oflag)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void BM_mesh_delete_hflag_tagged(BMesh *bm, const char hflag, const char htype)
struct BMLoop * next
struct BMEdge * e
struct BMVert * v