Blender V5.3
bmesh_mesh.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_listBase.h"
14
15#include "BLI_listbase.hh"
16#include "BLI_math_matrix_c.hh"
17#include "BLI_math_vector_c.hh"
18
19#include "BKE_customdata.hh"
20#include "BKE_mesh.hh"
21
22#include "bmesh.hh"
23
24namespace blender {
25
26const BMAllocTemplate bm_mesh_allocsize_default = {512, 1024, 2048, 512};
27const BMAllocTemplate bm_mesh_chunksize_default = {512, 1024, 2048, 512};
28
29static void bm_mempool_init_ex(const BMAllocTemplate *allocsize,
30 const bool use_toolflags,
31 BLI_mempool **r_vpool,
32 BLI_mempool **r_epool,
33 BLI_mempool **r_lpool,
34 BLI_mempool **r_fpool)
35{
36 size_t vert_size, edge_size, loop_size, face_size;
37
38 if (use_toolflags == true) {
39 vert_size = sizeof(BMVert_OFlag);
40 edge_size = sizeof(BMEdge_OFlag);
41 loop_size = sizeof(BMLoop);
42 face_size = sizeof(BMFace_OFlag);
43 }
44 else {
45 vert_size = sizeof(BMVert);
46 edge_size = sizeof(BMEdge);
47 loop_size = sizeof(BMLoop);
48 face_size = sizeof(BMFace);
49 }
50
51 if (r_vpool) {
52 *r_vpool = BLI_mempool_create(
54 }
55 if (r_epool) {
56 *r_epool = BLI_mempool_create(
58 }
59 if (r_lpool) {
60 *r_lpool = BLI_mempool_create(
62 }
63 if (r_fpool) {
64 *r_fpool = BLI_mempool_create(
66 }
67}
68
69static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize, const bool use_toolflags)
70{
71 bm_mempool_init_ex(allocsize, use_toolflags, &bm->vpool, &bm->epool, &bm->lpool, &bm->fpool);
72
73#ifdef USE_BMESH_HOLES
74 bm->looplistpool = BLI_mempool_create(sizeof(BMLoopList), 512, 512, BLI_MEMPOOL_NOP);
75#endif
76}
77
79{
81
83 return;
84 }
85
89
90 BMIter iter;
91 BMVert_OFlag *v_olfag;
92 BLI_mempool *toolflagpool = bm->vtoolflagpool;
93 BM_ITER_MESH (v_olfag, &iter, bm, BM_VERTS_OF_MESH) {
94 v_olfag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(toolflagpool));
95 }
96
97 BMEdge_OFlag *e_olfag;
98 toolflagpool = bm->etoolflagpool;
99 BM_ITER_MESH (e_olfag, &iter, bm, BM_EDGES_OF_MESH) {
100 e_olfag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(toolflagpool));
101 }
102
103 BMFace_OFlag *f_olfag;
104 toolflagpool = bm->ftoolflagpool;
105 BM_ITER_MESH (f_olfag, &iter, bm, BM_FACES_OF_MESH) {
106 f_olfag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(toolflagpool));
107 }
108
109 bm->totflags = 1;
110}
111
113{
114 if (bm->vtoolflagpool) {
116 bm->vtoolflagpool = nullptr;
117 }
118 if (bm->etoolflagpool) {
120 bm->etoolflagpool = nullptr;
121 }
122 if (bm->ftoolflagpool) {
124 bm->ftoolflagpool = nullptr;
125 }
126}
127
128BMesh *BM_mesh_create(const BMAllocTemplate *allocsize, const BMeshCreateParams *params)
129{
130 /* allocate the structure */
131 BMesh *bm = MEM_new<BMesh>(__func__);
132
133 /* allocate the memory pools for the mesh elements */
134 bm_mempool_init(bm, allocsize, params->use_toolflags);
135
136 /* allocate one flag pool that we don't get rid of. */
137 bm->use_toolflags = params->use_toolflags;
138 bm->toolflag_index = 0;
139 bm->totflags = 0;
140
145
146 return bm;
147}
148
150{
151 BMVert *v;
152 BMEdge *e;
153 BMLoop *l;
154 BMFace *f;
155
156 BMIter iter;
157 BMIter itersub;
158
159 const bool is_ldata_free = CustomData_bmesh_has_free(&bm->ldata);
160 const bool is_pdata_free = CustomData_bmesh_has_free(&bm->pdata);
161
162 /* Check if we have to call free, if not we can avoid a lot of looping */
164 BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
166 }
167 }
169 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
171 }
172 }
173
174 if (is_ldata_free || is_pdata_free) {
175 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
176 if (is_pdata_free) {
178 }
179 if (is_ldata_free) {
180 BM_ITER_ELEM (l, &itersub, f, BM_LOOPS_OF_FACE) {
182 }
183 }
184 }
185 }
186
187 /* Free custom data pools, This should probably go in CustomData_free? */
188 if (bm->vdata.totlayer) {
190 }
191 if (bm->edata.totlayer) {
193 }
194 if (bm->ldata.totlayer) {
196 }
197 if (bm->pdata.totlayer) {
199 }
200
201 /* free custom data */
206
207 /* destroy element pools */
212
213 if (bm->vtable) {
214 MEM_delete(bm->vtable);
215 }
216 if (bm->etable) {
217 MEM_delete(bm->etable);
218 }
219 if (bm->ftable) {
220 MEM_delete(bm->ftable);
221 }
222
223 /* destroy flag pool */
225
226#ifdef USE_BMESH_HOLES
227 BLI_mempool_destroy(bm->looplistpool);
228#endif
229
230 bm->selected.free_no_destruct();
231
232 if (bm->lnor_spacearr) {
234 MEM_delete(bm->lnor_spacearr);
235 }
236
238}
239
241{
242 const bool use_toolflags = bm->use_toolflags;
243 void *py_handle = bm->py_handle;
244
245 /* free old mesh */
247 *bm = BMesh{};
248
249 /* allocate the memory pools for the mesh elements */
251
252 bm->use_toolflags = use_toolflags;
253 bm->py_handle = py_handle;
254
255 bm->toolflag_index = 0;
256 bm->totflags = 0;
257
262}
263
265{
267
268 if (bm->py_handle) {
269 /* keep this out of 'BM_mesh_data_free' because we want python
270 * to be able to clear the mesh and maintain access. */
272 bm->py_handle = nullptr;
273 }
274
275 MEM_delete(bm);
276}
277
278void bmesh_edit_begin(BMesh * /*bm*/, BMOpTypeFlag /*type_flag*/)
279{
280 /* Most operators seem to be using BMO_OPTYPE_FLAG_UNTAN_MULTIRES to change the MDisps to
281 * absolute space during mesh edits. With this enabled, changes to the topology
282 * (loop cuts, edge subdivides, etc) are not reflected in the higher levels of
283 * the mesh at all, which doesn't seem right. Turning off completely for now,
284 * until this is shown to be better for certain types of mesh edits. */
285#ifdef BMOP_UNTAN_MULTIRES_ENABLED
286 /* switch multires data out of tangent space */
288 {
289 bmesh_mdisps_space_set(bm, MULTIRES_SPACE_TANGENT, MULTIRES_SPACE_ABSOLUTE);
290
291 /* ensure correct normals, if possible */
292 bmesh_rationalize_normals(bm, 0);
294 }
295#endif
296}
297
299{
300 ListBaseT<BMEditSelection> select_history;
301
302 /* BMO_OPTYPE_FLAG_UNTAN_MULTIRES disabled for now, see comment above in bmesh_edit_begin. */
303#ifdef BMOP_UNTAN_MULTIRES_ENABLED
304 /* switch multires data into tangent space */
306 /* set normals to their previous winding */
307 bmesh_rationalize_normals(bm, 1);
308 bmesh_mdisps_space_set(bm, MULTIRES_SPACE_ABSOLUTE, MULTIRES_SPACE_TANGENT);
309 }
310 else if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) {
311 bmesh_rationalize_normals(bm, 1);
312 }
313#endif
314
315 /* compute normals, clear temp flags and flush selections */
316 if (type_flag & BMO_OPTYPE_FLAG_NORMALS_CALC) {
319 }
320
321 if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) {
322 select_history = bm->selected;
323 bm->selected.clear_no_delete();
324 }
325
326 if (type_flag & BMO_OPTYPE_FLAG_SELECT_FLUSH) {
328 }
329
330 if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) {
331 bm->selected = select_history;
332 }
333 if (type_flag & BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL) {
335 }
336}
337
338void BM_mesh_elem_index_ensure_ex(BMesh *bm, const char htype, int elem_offset[4])
339{
340
341#ifndef NDEBUG
342 BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__);
343#endif
344
345 if (elem_offset == nullptr) {
346 /* Simple case. */
347 const char htype_needed = bm->elem_index_dirty & htype;
348 if (htype_needed == 0) {
349 goto finally;
350 }
351 }
352
353 if (htype & BM_VERT) {
354 if ((bm->elem_index_dirty & BM_VERT) || (elem_offset && elem_offset[0])) {
355 BMIter iter;
356 BMElem *ele;
357
358 int index = elem_offset ? elem_offset[0] : 0;
359 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
360 BM_elem_index_set(ele, index++); /* set_ok */
361 }
362 BLI_assert(elem_offset || index == bm->totvert);
363 }
364 else {
365 // printf("%s: skipping vert index calc!\n", __func__);
366 }
367 }
368
369 if (htype & BM_EDGE) {
370 if ((bm->elem_index_dirty & BM_EDGE) || (elem_offset && elem_offset[1])) {
371 BMIter iter;
372 BMElem *ele;
373
374 int index = elem_offset ? elem_offset[1] : 0;
375 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
376 BM_elem_index_set(ele, index++); /* set_ok */
377 }
378 BLI_assert(elem_offset || index == bm->totedge);
379 }
380 else {
381 // printf("%s: skipping edge index calc!\n", __func__);
382 }
383 }
384
385 if (htype & (BM_FACE | BM_LOOP)) {
386 if ((bm->elem_index_dirty & (BM_FACE | BM_LOOP)) ||
387 (elem_offset && (elem_offset[2] || elem_offset[3])))
388 {
389 BMIter iter;
390 BMElem *ele;
391
392 const bool update_face = (htype & BM_FACE) && (bm->elem_index_dirty & BM_FACE);
393 const bool update_loop = (htype & BM_LOOP) && (bm->elem_index_dirty & BM_LOOP);
394
395 int index_loop = elem_offset ? elem_offset[2] : 0;
396 int index = elem_offset ? elem_offset[3] : 0;
397
398 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
399 if (update_face) {
400 BM_elem_index_set(ele, index++); /* set_ok */
401 }
402
403 if (update_loop) {
404 BMLoop *l_iter, *l_first;
405
406 l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)ele);
407 do {
408 BM_elem_index_set(l_iter, index_loop++); /* set_ok */
409 } while ((l_iter = l_iter->next) != l_first);
410 }
411 }
412
413 BLI_assert(elem_offset || !update_face || index == bm->totface);
414 if (update_loop) {
415 BLI_assert(elem_offset || !update_loop || index_loop == bm->totloop);
416 }
417 }
418 else {
419 // printf("%s: skipping face/loop index calc!\n", __func__);
420 }
421 }
422
423finally:
424 bm->elem_index_dirty &= ~htype;
425 if (elem_offset) {
426 if (htype & BM_VERT) {
427 elem_offset[0] += bm->totvert;
428 if (elem_offset[0] != bm->totvert) {
430 }
431 }
432 if (htype & BM_EDGE) {
433 elem_offset[1] += bm->totedge;
434 if (elem_offset[1] != bm->totedge) {
436 }
437 }
438 if (htype & BM_LOOP) {
439 elem_offset[2] += bm->totloop;
440 if (elem_offset[2] != bm->totloop) {
442 }
443 }
444 if (htype & BM_FACE) {
445 elem_offset[3] += bm->totface;
446 if (elem_offset[3] != bm->totface) {
448 }
449 }
450 }
451}
452
453void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
454{
455 BM_mesh_elem_index_ensure_ex(bm, htype, nullptr);
456}
457
459 BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b)
460{
461 const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
462
463 const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
464 const char *type_names[3] = {"vert", "edge", "face"};
465
466 BMIter iter;
467 BMElem *ele;
468 int i;
469 bool is_any_error = false;
470
471 for (i = 0; i < 3; i++) {
472 const bool is_dirty = (flag_types[i] & bm->elem_index_dirty) != 0;
473 int index = 0;
474 bool is_error = false;
475 int err_val = 0;
476 int err_idx = 0;
477
478 BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
479 if (!is_dirty) {
480 if (BM_elem_index_get(ele) != index) {
481 err_val = BM_elem_index_get(ele);
482 err_idx = index;
483 is_error = true;
484 break;
485 }
486 }
487 index++;
488 }
489
490 if ((is_error == true) && (is_dirty == false)) {
491 is_any_error = true;
492 fprintf(stderr,
493 "Invalid Index: at %s, %s, %s[%d] invalid index %d, '%s', '%s'\n",
494 location,
495 func,
496 type_names[i],
497 err_idx,
498 err_val,
499 msg_a,
500 msg_b);
501 }
502 else if ((is_error == false) && (is_dirty == true)) {
503
504#if 0 /* mostly annoying */
505
506 /* dirty may have been incorrectly set */
507 fprintf(stderr,
508 "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are "
509 "correct, '%s', '%s'\n",
510 location,
511 func,
512 type_names[i],
513 msg_a,
514 msg_b);
515#endif
516 }
517 }
518
519#if 0 /* mostly annoying, even in debug mode */
520# ifndef NDEBUG
521 if (is_any_error == 0) {
522 fprintf(stderr, "Valid Index Success: at %s, %s, '%s', '%s'\n", location, func, msg_a, msg_b);
523 }
524# endif
525#endif
526 (void)is_any_error; /* shut up the compiler */
527}
528
529/* debug check only - no need to optimize */
530#ifndef NDEBUG
532{
533 BMIter iter;
534 BMElem *ele;
535 int i;
536
537 if (bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) {
538 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
539 if (ele != reinterpret_cast<BMElem *>(bm->vtable[i])) {
540 return false;
541 }
542 }
543 }
544
545 if (bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) {
546 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
547 if (ele != reinterpret_cast<BMElem *>(bm->etable[i])) {
548 return false;
549 }
550 }
551 }
552
553 if (bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) {
554 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
555 if (ele != reinterpret_cast<BMElem *>(bm->ftable[i])) {
556 return false;
557 }
558 }
559 }
560
561 return true;
562}
563#endif
564
565void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
566{
567 /* assume if the array is non-null then its valid and no need to recalc */
568 const char htype_needed =
569 (((bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) ? 0 : BM_VERT) |
570 ((bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) ? 0 : BM_EDGE) |
571 ((bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) ? 0 : BM_FACE)) &
572 htype;
573
574 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
575
576 /* in debug mode double check we didn't need to recalculate */
578
579 if (htype_needed == 0) {
580 goto finally;
581 }
582
583 if (htype_needed & BM_VERT) {
584 if (bm->vtable && bm->totvert <= bm->vtable_tot && bm->totvert * 2 >= bm->vtable_tot) {
585 /* pass (re-use the array) */
586 }
587 else {
588 if (bm->vtable) {
589 MEM_delete(bm->vtable);
590 }
593 }
595 bm, BM_VERTS_OF_MESH, nullptr, reinterpret_cast<void **>(bm->vtable), bm->totvert);
596 }
597 if (htype_needed & BM_EDGE) {
598 if (bm->etable && bm->totedge <= bm->etable_tot && bm->totedge * 2 >= bm->etable_tot) {
599 /* pass (re-use the array) */
600 }
601 else {
602 if (bm->etable) {
603 MEM_delete(bm->etable);
604 }
607 }
609 bm, BM_EDGES_OF_MESH, nullptr, reinterpret_cast<void **>(bm->etable), bm->totedge);
610 }
611 if (htype_needed & BM_FACE) {
612 if (bm->ftable && bm->totface <= bm->ftable_tot && bm->totface * 2 >= bm->ftable_tot) {
613 /* pass (re-use the array) */
614 }
615 else {
616 if (bm->ftable) {
617 MEM_delete(bm->ftable);
618 }
621 }
623 bm, BM_FACES_OF_MESH, nullptr, reinterpret_cast<void **>(bm->ftable), bm->totface);
624 }
625
626finally:
627 /* Only clear dirty flags when all the pointers and data are actually valid.
628 * This prevents possible threading issues when dirty flag check failed but
629 * data wasn't ready still.
630 */
631 bm->elem_table_dirty &= ~htype_needed;
632}
633
634void BM_mesh_elem_table_init(BMesh *bm, const char htype)
635{
636 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
637
638 /* force recalc */
641}
642
643void BM_mesh_elem_table_free(BMesh *bm, const char htype)
644{
645 if (htype & BM_VERT) {
646 MEM_SAFE_DELETE(bm->vtable);
647 }
648
649 if (htype & BM_EDGE) {
650 MEM_SAFE_DELETE(bm->etable);
651 }
652
653 if (htype & BM_FACE) {
654 MEM_SAFE_DELETE(bm->ftable);
655 }
656}
657
659{
660 return static_cast<BMVert *>(BLI_mempool_findelem(bm->vpool, index));
661}
662
664{
665 return static_cast<BMEdge *>(BLI_mempool_findelem(bm->epool, index));
666}
667
669{
670 return static_cast<BMFace *>(BLI_mempool_findelem(bm->fpool, index));
671}
672
674{
675 BMIter iter;
676 BMFace *f;
677 int i = index;
678 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
679 if (i < f->len) {
680 BMLoop *l_first, *l_iter;
681 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
682 do {
683 if (i == 0) {
684 return l_iter;
685 }
686 i -= 1;
687 } while ((l_iter = l_iter->next) != l_first);
688 }
689 i -= f->len;
690 }
691 return nullptr;
692}
693
695{
696 if ((bm->elem_table_dirty & BM_VERT) == 0) {
697 return (index < bm->totvert) ? bm->vtable[index] : nullptr;
698 }
700}
701
703{
704 if ((bm->elem_table_dirty & BM_EDGE) == 0) {
705 return (index < bm->totedge) ? bm->etable[index] : nullptr;
706 }
708}
709
711{
712 if ((bm->elem_table_dirty & BM_FACE) == 0) {
713 return (index < bm->totface) ? bm->ftable[index] : nullptr;
714 }
716}
717
718int BM_mesh_elem_count(BMesh *bm, const char htype)
719{
720 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
721
722 switch (htype) {
723 case BM_VERT:
724 return bm->totvert;
725 case BM_EDGE:
726 return bm->totedge;
727 case BM_FACE:
728 return bm->totface;
729 default: {
730 BLI_assert(0);
731 return 0;
732 }
733 }
734}
735
736void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const uint *face_idx)
737{
738 /* Mapping old to new pointers. */
739 Map<BMVert *, BMVert *> *vptr_map = nullptr;
740 Map<BMEdge *, BMEdge *> *eptr_map = nullptr;
741 Map<BMFace *, BMFace *> *fptr_map = nullptr;
742 BMIter iter, iterl;
743 BMVert *ve;
744 BMEdge *ed;
745 BMFace *fa;
746 BMLoop *lo;
747
748 if (!(vert_idx || edge_idx || face_idx)) {
749 return;
750 }
751
753 bm, (vert_idx ? BM_VERT : 0) | (edge_idx ? BM_EDGE : 0) | (face_idx ? BM_FACE : 0));
754
755 /* Remap Verts */
756 if (vert_idx) {
757 BMVert **verts_pool, *verts_copy, **vep;
758 const int totvert = bm->totvert;
759 int i;
760 const uint *new_idx;
761 /* Special case: Python uses custom data layers to hold PyObject references.
762 * These have to be kept in place, else the PyObjects we point to, won't point back to us. */
763 const int cd_vert_pyptr = CustomData_get_offset(&bm->vdata, CD_BM_ELEM_PYPTR);
764
765 /* Make a copy of all vertices. */
766 verts_pool = bm->vtable;
767 verts_copy = MEM_new_array_uninitialized<BMVert>(totvert, __func__);
768 void **pyptrs = (cd_vert_pyptr != -1) ?
769 MEM_new_array_uninitialized<void *>(totvert, __func__) :
770 nullptr;
771 for (i = totvert, ve = verts_copy + totvert - 1, vep = verts_pool + totvert - 1; i--;
772 ve--, vep--)
773 {
774 *ve = **vep;
775 // printf("*vep: %p, verts_pool[%d]: %p\n", *vep, i, verts_pool[i]);
776 if (cd_vert_pyptr != -1) {
777 void **pyptr = static_cast<void **>(BM_ELEM_CD_GET_VOID_P(((BMElem *)ve), cd_vert_pyptr));
778 pyptrs[i] = *pyptr;
779 }
780 }
781
782 /* Init the old-to-new vert pointers mapping. */
783 vptr_map = MEM_new<Map<BMVert *, BMVert *>>(__func__);
784 vptr_map->reserve(bm->totvert);
785
786 /* Copy back verts to their new place, and update old2new pointers mapping. */
787 new_idx = vert_idx + totvert - 1;
788 ve = verts_copy + totvert - 1;
789 vep = verts_pool + totvert - 1; /* old, org pointer */
790 for (i = totvert; i--; new_idx--, ve--, vep--) {
791 BMVert *new_vep = verts_pool[*new_idx];
792 *new_vep = *ve;
793#if 0
794 printf(
795 "mapping vert from %d to %d (%p/%p to %p)\n", i, *new_idx, *vep, verts_pool[i], new_vep);
796#endif
797 vptr_map->add(*vep, new_vep);
798 if (cd_vert_pyptr != -1) {
799 void **pyptr = static_cast<void **>(
800 BM_ELEM_CD_GET_VOID_P(((BMElem *)new_vep), cd_vert_pyptr));
801 *pyptr = pyptrs[*new_idx];
802 }
803 }
806
807 MEM_delete(verts_copy);
808 if (pyptrs) {
809 MEM_delete(pyptrs);
810 }
811 }
812
813 /* Remap Edges */
814 if (edge_idx) {
815 BMEdge **edges_pool, *edges_copy, **edp;
816 const int totedge = bm->totedge;
817 int i;
818 const uint *new_idx;
819 /* Special case: Python uses custom data layers to hold PyObject references.
820 * These have to be kept in place, else the PyObjects we point to, won't point back to us. */
821 const int cd_edge_pyptr = CustomData_get_offset(&bm->edata, CD_BM_ELEM_PYPTR);
822
823 /* Make a copy of all vertices. */
824 edges_pool = bm->etable;
825 edges_copy = MEM_new_array_uninitialized<BMEdge>(totedge, __func__);
826 void **pyptrs = (cd_edge_pyptr != -1) ?
827 MEM_new_array_uninitialized<void *>(totedge, __func__) :
828 nullptr;
829 for (i = totedge, ed = edges_copy + totedge - 1, edp = edges_pool + totedge - 1; i--;
830 ed--, edp--)
831 {
832 *ed = **edp;
833 if (cd_edge_pyptr != -1) {
834 void **pyptr = static_cast<void **>(BM_ELEM_CD_GET_VOID_P(((BMElem *)ed), cd_edge_pyptr));
835 pyptrs[i] = *pyptr;
836 }
837 }
838
839 /* Init the old-to-new vert pointers mapping. */
840 eptr_map = MEM_new<Map<BMEdge *, BMEdge *>>(__func__);
841 eptr_map->reserve(totedge);
842
843 /* Copy back verts to their new place, and update old2new pointers mapping. */
844 new_idx = edge_idx + totedge - 1;
845 ed = edges_copy + totedge - 1;
846 edp = edges_pool + totedge - 1; /* old, org pointer */
847 for (i = totedge; i--; new_idx--, ed--, edp--) {
848 BMEdge *new_edp = edges_pool[*new_idx];
849 *new_edp = *ed;
850 eptr_map->add(*edp, new_edp);
851#if 0
852 printf(
853 "mapping edge from %d to %d (%p/%p to %p)\n", i, *new_idx, *edp, edges_pool[i], new_edp);
854#endif
855 if (cd_edge_pyptr != -1) {
856 void **pyptr = static_cast<void **>(
857 BM_ELEM_CD_GET_VOID_P(((BMElem *)new_edp), cd_edge_pyptr));
858 *pyptr = pyptrs[*new_idx];
859 }
860 }
863
864 MEM_delete(edges_copy);
865 if (pyptrs) {
866 MEM_delete(pyptrs);
867 }
868 }
869
870 /* Remap Faces */
871 if (face_idx) {
872 BMFace **faces_pool, *faces_copy, **fap;
873 const int totface = bm->totface;
874 int i;
875 const uint *new_idx;
876 /* Special case: Python uses custom data layers to hold PyObject references.
877 * These have to be kept in place, else the PyObjects we point to, won't point back to us. */
878 const int cd_poly_pyptr = CustomData_get_offset(&bm->pdata, CD_BM_ELEM_PYPTR);
879
880 /* Make a copy of all vertices. */
881 faces_pool = bm->ftable;
882 faces_copy = MEM_new_array_uninitialized<BMFace>(totface, __func__);
883 void **pyptrs = (cd_poly_pyptr != -1) ?
884 MEM_new_array_uninitialized<void *>(totface, __func__) :
885 nullptr;
886 for (i = totface, fa = faces_copy + totface - 1, fap = faces_pool + totface - 1; i--;
887 fa--, fap--)
888 {
889 *fa = **fap;
890 if (cd_poly_pyptr != -1) {
891 void **pyptr = static_cast<void **>(BM_ELEM_CD_GET_VOID_P(((BMElem *)fa), cd_poly_pyptr));
892 pyptrs[i] = *pyptr;
893 }
894 }
895
896 /* Init the old-to-new vert pointers mapping. */
897 fptr_map = MEM_new<Map<BMFace *, BMFace *>>(__func__);
898 fptr_map->reserve(totface);
899
900 /* Copy back verts to their new place, and update old2new pointers mapping. */
901 new_idx = face_idx + totface - 1;
902 fa = faces_copy + totface - 1;
903 fap = faces_pool + totface - 1; /* old, org pointer */
904 for (i = totface; i--; new_idx--, fa--, fap--) {
905 BMFace *new_fap = faces_pool[*new_idx];
906 *new_fap = *fa;
907 fptr_map->add(*fap, new_fap);
908 if (cd_poly_pyptr != -1) {
909 void **pyptr = static_cast<void **>(
910 BM_ELEM_CD_GET_VOID_P(((BMElem *)new_fap), cd_poly_pyptr));
911 *pyptr = pyptrs[*new_idx];
912 }
913 }
914
917
918 MEM_delete(faces_copy);
919 if (pyptrs) {
920 MEM_delete(pyptrs);
921 }
922 }
923
924 /* And now, fix all vertices/edges/faces/loops pointers! */
925 /* Verts' pointers, only edge pointers... */
926 if (eptr_map) {
927 BM_ITER_MESH (ve, &iter, bm, BM_VERTS_OF_MESH) {
928 // printf("Vert e: %p -> %p\n", ve->e, BLI_ghash_lookup(eptr_map, ve->e));
929 if (ve->e) {
930 ve->e = eptr_map->lookup(ve->e);
931 }
932 }
933 }
934
935 /* Edges' pointers, only vert pointers (as we don't mess with loops!),
936 * and - ack! - edge pointers,
937 * as we have to handle disk-links. */
938 if (vptr_map || eptr_map) {
940 if (vptr_map) {
941#if 0
942 printf("Edge v1: %p -> %p\n", ed->v1, BLI_ghash_lookup(vptr_map, ed->v1));
943 printf("Edge v2: %p -> %p\n", ed->v2, BLI_ghash_lookup(vptr_map, ed->v2));
944#endif
945 ed->v1 = vptr_map->lookup(ed->v1);
946 ed->v2 = vptr_map->lookup(ed->v2);
947 }
948 if (eptr_map) {
949#if 0
950 printf("Edge v1_disk_link prev: %p -> %p\n",
951 ed->v1_disk_link.prev,
952 BLI_ghash_lookup(eptr_map, ed->v1_disk_link.prev));
953 printf("Edge v1_disk_link next: %p -> %p\n",
954 ed->v1_disk_link.next,
955 BLI_ghash_lookup(eptr_map, ed->v1_disk_link.next));
956 printf("Edge v2_disk_link prev: %p -> %p\n",
957 ed->v2_disk_link.prev,
958 BLI_ghash_lookup(eptr_map, ed->v2_disk_link.prev));
959 printf("Edge v2_disk_link next: %p -> %p\n",
960 ed->v2_disk_link.next,
961 BLI_ghash_lookup(eptr_map, ed->v2_disk_link.next));
962#endif
963 ed->v1_disk_link.prev = eptr_map->lookup(ed->v1_disk_link.prev);
964 ed->v1_disk_link.next = eptr_map->lookup(ed->v1_disk_link.next);
965 ed->v2_disk_link.prev = eptr_map->lookup(ed->v2_disk_link.prev);
966 ed->v2_disk_link.next = eptr_map->lookup(ed->v2_disk_link.next);
967 }
968 }
969 }
970
971 /* Faces' pointers (loops, in fact), always needed... */
972 BM_ITER_MESH (fa, &iter, bm, BM_FACES_OF_MESH) {
973 BM_ITER_ELEM (lo, &iterl, fa, BM_LOOPS_OF_FACE) {
974 if (vptr_map) {
975 // printf("Loop v: %p -> %p\n", lo->v, BLI_ghash_lookup(vptr_map, lo->v));
976 lo->v = vptr_map->lookup(lo->v);
977 }
978 if (eptr_map) {
979 // printf("Loop e: %p -> %p\n", lo->e, BLI_ghash_lookup(eptr_map, lo->e));
980 lo->e = eptr_map->lookup(lo->e);
981 }
982 if (fptr_map) {
983 // printf("Loop f: %p -> %p\n", lo->f, BLI_ghash_lookup(fptr_map, lo->f));
984 lo->f = fptr_map->lookup(lo->f);
985 }
986 }
987 }
988
989 /* Selection history */
990 {
991 for (BMEditSelection &ese : bm->selected) {
992 switch (ese.htype) {
993 case BM_VERT:
994 if (vptr_map) {
995 ese.ele = reinterpret_cast<BMElem *>(
996 vptr_map->lookup(reinterpret_cast<BMVert *>(ese.ele)));
997 }
998 break;
999 case BM_EDGE:
1000 if (eptr_map) {
1001 ese.ele = reinterpret_cast<BMElem *>(
1002 eptr_map->lookup(reinterpret_cast<BMEdge *>(ese.ele)));
1003 }
1004 break;
1005 case BM_FACE:
1006 if (fptr_map) {
1007 ese.ele = reinterpret_cast<BMElem *>(
1008 fptr_map->lookup(reinterpret_cast<BMFace *>(ese.ele)));
1009 }
1010 break;
1011 }
1012 }
1013 }
1014
1015 if (fptr_map) {
1016 if (bm->act_face) {
1017 bm->act_face = fptr_map->lookup(bm->act_face);
1018 }
1019 }
1020
1021 MEM_delete(vptr_map);
1022 MEM_delete(eptr_map);
1023 MEM_delete(fptr_map);
1024}
1025
1027 const BMeshCreateParams *params,
1028 BLI_mempool *vpool_dst,
1029 BLI_mempool *epool_dst,
1030 BLI_mempool *lpool_dst,
1031 BLI_mempool *fpool_dst)
1032{
1033 const char remap = (vpool_dst ? BM_VERT : 0) | (epool_dst ? BM_EDGE : 0) |
1034 (lpool_dst ? BM_LOOP : 0) | (fpool_dst ? BM_FACE : 0);
1035
1036 BMVert **vtable_dst = (remap & BM_VERT) ?
1038 nullptr;
1039 BMEdge **etable_dst = (remap & BM_EDGE) ?
1041 nullptr;
1042 BMLoop **ltable_dst = (remap & BM_LOOP) ?
1044 nullptr;
1045 BMFace **ftable_dst = (remap & BM_FACE) ?
1047 nullptr;
1048
1049 const bool use_toolflags = params->use_toolflags;
1050
1051 if (remap & BM_VERT) {
1052 BMIter iter;
1053 int index;
1054 BMVert *v_src;
1055 BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, index) {
1056 BMVert *v_dst = static_cast<BMVert *>(BLI_mempool_alloc(vpool_dst));
1057 memcpy(v_dst, v_src, sizeof(BMVert));
1058 if (use_toolflags) {
1059 (reinterpret_cast<BMVert_OFlag *>(v_dst))->oflags =
1061 nullptr;
1062 }
1063
1064 vtable_dst[index] = v_dst;
1065 BM_elem_index_set(v_src, index); /* set_ok */
1066 }
1067 }
1068
1069 if (remap & BM_EDGE) {
1070 BMIter iter;
1071 int index;
1072 BMEdge *e_src;
1073 BM_ITER_MESH_INDEX (e_src, &iter, bm, BM_EDGES_OF_MESH, index) {
1074 BMEdge *e_dst = static_cast<BMEdge *>(BLI_mempool_alloc(epool_dst));
1075 memcpy(e_dst, e_src, sizeof(BMEdge));
1076 if (use_toolflags) {
1077 (reinterpret_cast<BMEdge_OFlag *>(e_dst))->oflags =
1079 nullptr;
1080 }
1081
1082 etable_dst[index] = e_dst;
1083 BM_elem_index_set(e_src, index); /* set_ok */
1084 }
1085 }
1086
1087 if (remap & (BM_LOOP | BM_FACE)) {
1088 BMIter iter;
1089 int index, index_loop = 0;
1090 BMFace *f_src;
1091 BM_ITER_MESH_INDEX (f_src, &iter, bm, BM_FACES_OF_MESH, index) {
1092
1093 if (remap & BM_FACE) {
1094 BMFace *f_dst = static_cast<BMFace *>(BLI_mempool_alloc(fpool_dst));
1095 memcpy(f_dst, f_src, sizeof(BMFace));
1096 if (use_toolflags) {
1097 (reinterpret_cast<BMFace_OFlag *>(f_dst))->oflags =
1098 bm->ftoolflagpool ?
1100 nullptr;
1101 }
1102
1103 ftable_dst[index] = f_dst;
1104 BM_elem_index_set(f_src, index); /* set_ok */
1105 }
1106
1107 /* handle loops */
1108 if (remap & BM_LOOP) {
1109 BMLoop *l_iter_src, *l_first_src;
1110 l_iter_src = l_first_src = BM_FACE_FIRST_LOOP((BMFace *)f_src);
1111 do {
1112 BMLoop *l_dst = static_cast<BMLoop *>(BLI_mempool_alloc(lpool_dst));
1113 memcpy(l_dst, l_iter_src, sizeof(BMLoop));
1114 ltable_dst[index_loop] = l_dst;
1115 BM_elem_index_set(l_iter_src, index_loop++); /* set_ok */
1116 } while ((l_iter_src = l_iter_src->next) != l_first_src);
1117 }
1118 }
1119 }
1120
1121#define MAP_VERT(ele) vtable_dst[BM_elem_index_get(ele)]
1122#define MAP_EDGE(ele) etable_dst[BM_elem_index_get(ele)]
1123#define MAP_LOOP(ele) ltable_dst[BM_elem_index_get(ele)]
1124#define MAP_FACE(ele) ftable_dst[BM_elem_index_get(ele)]
1125
1126#define REMAP_VERT(ele) \
1127 { \
1128 if (remap & BM_VERT) { \
1129 ele = MAP_VERT(ele); \
1130 } \
1131 } \
1132 ((void)0)
1133#define REMAP_EDGE(ele) \
1134 { \
1135 if (remap & BM_EDGE) { \
1136 ele = MAP_EDGE(ele); \
1137 } \
1138 } \
1139 ((void)0)
1140#define REMAP_LOOP(ele) \
1141 { \
1142 if (remap & BM_LOOP) { \
1143 ele = MAP_LOOP(ele); \
1144 } \
1145 } \
1146 ((void)0)
1147#define REMAP_FACE(ele) \
1148 { \
1149 if (remap & BM_FACE) { \
1150 ele = MAP_FACE(ele); \
1151 } \
1152 } \
1153 ((void)0)
1154
1155 /* verts */
1156 {
1157 for (int i = 0; i < bm->totvert; i++) {
1158 BMVert *v = vtable_dst[i];
1159 if (v->e) {
1160 REMAP_EDGE(v->e);
1161 }
1162 }
1163 }
1164
1165 /* edges */
1166 {
1167 for (int i = 0; i < bm->totedge; i++) {
1168 BMEdge *e = etable_dst[i];
1169 REMAP_VERT(e->v1);
1170 REMAP_VERT(e->v2);
1171 REMAP_EDGE(e->v1_disk_link.next);
1172 REMAP_EDGE(e->v1_disk_link.prev);
1173 REMAP_EDGE(e->v2_disk_link.next);
1174 REMAP_EDGE(e->v2_disk_link.prev);
1175 if (e->l) {
1176 REMAP_LOOP(e->l);
1177 }
1178 }
1179 }
1180
1181 /* faces */
1182 {
1183 for (int i = 0; i < bm->totface; i++) {
1184 BMFace *f = ftable_dst[i];
1185 REMAP_LOOP(f->l_first);
1186
1187 {
1188 BMLoop *l_iter, *l_first;
1189 l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)f);
1190 do {
1191 REMAP_VERT(l_iter->v);
1192 REMAP_EDGE(l_iter->e);
1193 REMAP_FACE(l_iter->f);
1194
1195 REMAP_LOOP(l_iter->radial_next);
1196 REMAP_LOOP(l_iter->radial_prev);
1197 REMAP_LOOP(l_iter->next);
1198 REMAP_LOOP(l_iter->prev);
1199 } while ((l_iter = l_iter->next) != l_first);
1200 }
1201 }
1202 }
1203
1204 for (BMEditSelection &ese : bm->selected) {
1205 switch (ese.htype) {
1206 case BM_VERT:
1207 if (remap & BM_VERT) {
1208 ese.ele = reinterpret_cast<BMElem *>(MAP_VERT(ese.ele));
1209 }
1210 break;
1211 case BM_EDGE:
1212 if (remap & BM_EDGE) {
1213 ese.ele = reinterpret_cast<BMElem *>(MAP_EDGE(ese.ele));
1214 }
1215 break;
1216 case BM_FACE:
1217 if (remap & BM_FACE) {
1218 ese.ele = reinterpret_cast<BMElem *>(MAP_FACE(ese.ele));
1219 }
1220 break;
1221 }
1222 }
1223
1224 if (bm->act_face) {
1226 }
1227
1228#undef MAP_VERT
1229#undef MAP_EDGE
1230#undef MAP_LOOP
1231#undef MAP_EDGE
1232
1233#undef REMAP_VERT
1234#undef REMAP_EDGE
1235#undef REMAP_LOOP
1236#undef REMAP_EDGE
1237
1238 /* Cleanup, re-use local tables if the current mesh had tables allocated.
1239 * could use irrespective but it may use more memory than the caller wants
1240 * (and not be needed). */
1241 if (remap & BM_VERT) {
1242 if (bm->vtable) {
1243 std::swap(vtable_dst, bm->vtable);
1244 bm->vtable_tot = bm->totvert;
1246 }
1247 MEM_delete(vtable_dst);
1249 bm->vpool = vpool_dst;
1250 }
1251
1252 if (remap & BM_EDGE) {
1253 if (bm->etable) {
1254 std::swap(etable_dst, bm->etable);
1255 bm->etable_tot = bm->totedge;
1257 }
1258 MEM_delete(etable_dst);
1260 bm->epool = epool_dst;
1261 }
1262
1263 if (remap & BM_LOOP) {
1264 /* no loop table */
1265 MEM_delete(ltable_dst);
1267 bm->lpool = lpool_dst;
1268 }
1269
1270 if (remap & BM_FACE) {
1271 if (bm->ftable) {
1272 std::swap(ftable_dst, bm->ftable);
1273 bm->ftable_tot = bm->totface;
1275 }
1276 MEM_delete(ftable_dst);
1278 bm->fpool = fpool_dst;
1279 }
1280}
1281
1282void BM_mesh_toolflags_set(BMesh *bm, bool use_toolflags)
1283{
1284 if (bm->use_toolflags == use_toolflags) {
1285 return;
1286 }
1287
1288 const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_BM(bm);
1289
1290 BLI_mempool *vpool_dst = nullptr;
1291 BLI_mempool *epool_dst = nullptr;
1292 BLI_mempool *fpool_dst = nullptr;
1293
1294 bm_mempool_init_ex(&allocsize, use_toolflags, &vpool_dst, &epool_dst, nullptr, &fpool_dst);
1295
1296 if (use_toolflags == false) {
1300
1301 bm->vtoolflagpool = nullptr;
1302 bm->etoolflagpool = nullptr;
1303 bm->ftoolflagpool = nullptr;
1304 }
1305 BMeshCreateParams params = {};
1306 params.use_toolflags = use_toolflags;
1307
1308 BM_mesh_rebuild(bm, &params, vpool_dst, epool_dst, nullptr, fpool_dst);
1309
1310 bm->use_toolflags = use_toolflags;
1311}
1312
1313/* -------------------------------------------------------------------- */
1316
1318{
1319 BMIter iter;
1320 BMVert *v;
1321 int i;
1322 BM_ITER_MESH_INDEX (v, &iter, const_cast<BMesh *>(bm), BM_VERTS_OF_MESH, i) {
1323 positions[i] = v->co;
1324 }
1325}
1326
1328{
1329 BMIter iter;
1330 BMVert *v;
1331 int i;
1332 BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
1333 normals[i] = v->no;
1334 }
1335}
1336
1338{
1339 Array<float3> positions(bm->totvert);
1340 BM_mesh_vert_coords_get(bm, positions);
1341 return positions;
1342}
1343
1345{
1346 BMIter iter;
1347 BMVert *v;
1348 int i;
1349 BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
1350 copy_v3_v3(v->co, vert_coords[i]);
1351 }
1352}
1353
1355 const Span<float3> vert_coords,
1356 const float4x4 &transform)
1357{
1358 BMIter iter;
1359 BMVert *v;
1360 int i;
1361 BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
1362 mul_v3_m4v3(v->co, transform.ptr(), vert_coords[i]);
1363 }
1364}
1365
1367
1368} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
These structs are the foundation for all linked lists in the library system.
Read Blender memory allocation and freeing.
#define BM_ALL_NOLOOP
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_ELEM_INDEX_VALIDATE(_bm, _msg_a, _msg_b)
#define BM_elem_index_get(ele)
#define BM_elem_index_set(ele, index)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define REMAP_VERT(ele)
#define MAP_FACE(ele)
#define REMAP_LOOP(ele)
#define REMAP_EDGE(ele)
#define MAP_EDGE(ele)
#define MAP_VERT(ele)
#define REMAP_FACE(ele)
#define BMALLOC_TEMPLATE_FROM_BM(bm)
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
void reserve(int64_t n)
Definition BLI_map.hh:1028
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BM_mesh_vert_normals_get(BMesh *bm, MutableSpan< float3 > normals)
void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b)
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
BMFace * BM_face_at_index_find(BMesh *bm, const int index)
void BM_mesh_elem_toolflags_ensure(BMesh *bm)
Definition bmesh_mesh.cc:78
@ BM_SPACEARR_DIRTY_ALL
void BM_mesh_free(BMesh *bm)
BMesh Free Mesh.
void BM_mesh_data_free(BMesh *bm)
BMesh Free Mesh Data.
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BM_mesh_vert_coords_apply_with_mat4(BMesh *bm, const Span< float3 > vert_coords, const float4x4 &transform)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
void * BLI_ghash_lookup(const GHash *gh, const void *key) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.cc:735
void BM_mesh_vert_coords_apply(BMesh *bm, const Span< float3 > vert_coords)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
void BMO_error_clear(BMesh *bm)
BMVert * BM_vert_at_index_find_or_table(BMesh *bm, const int index)
static void bm_mempool_init_ex(const BMAllocTemplate *allocsize, const bool use_toolflags, BLI_mempool **r_vpool, BLI_mempool **r_epool, BLI_mempool **r_lpool, BLI_mempool **r_fpool)
Definition bmesh_mesh.cc:29
ATTR_WARN_UNUSED_RESULT const BMVert * v
MatBase< float, 4, 4 > float4x4
void BM_mesh_rebuild(BMesh *bm, const BMeshCreateParams *params, BLI_mempool *vpool_dst, BLI_mempool *epool_dst, BLI_mempool *lpool_dst, BLI_mempool *fpool_dst)
BMLoop * BM_loop_at_index_find(BMesh *bm, const int index)
void BM_mesh_select_mode_flush(BMesh *bm)
void BM_mesh_vert_coords_get(const BMesh *bm, MutableSpan< float3 > positions)
const BMAllocTemplate bm_mesh_chunksize_default
Definition bmesh_mesh.cc:27
BMVert * BM_vert_at_index_find(BMesh *bm, const int index)
void BLI_mempool_destroy(BLI_mempool *pool) ATTR_NONNULL(1)
void CustomData_bmesh_free_block(CustomData *data, void **block)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer * oflags
BMEdge * BM_edge_at_index_find(BMesh *bm, const int index)
void CustomData_reset(CustomData *data)
bool CustomData_bmesh_has_free(const CustomData *data)
BLI_mempool * BLI_mempool_create(unsigned int esize, unsigned int elem_num, unsigned int pchunk, unsigned int flag) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
BMFace * BM_face_at_index_find_or_table(BMesh *bm, const int index)
int BM_mesh_elem_count(BMesh *bm, const char htype)
void BM_mesh_clear(BMesh *bm)
BMesh Clear Mesh.
const BMAllocTemplate bm_mesh_allocsize_default
Definition bmesh_mesh.cc:26
Array< float3 > BM_mesh_vert_coords_alloc(const BMesh *bm)
void BM_mesh_toolflags_set(BMesh *bm, bool use_toolflags)
static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize, const bool use_toolflags)
Definition bmesh_mesh.cc:69
void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr)
void CustomData_free(CustomData *data)
@ BLI_MEMPOOL_NOP
@ BLI_MEMPOOL_ALLOW_ITER
@ BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL
@ BMO_OPTYPE_FLAG_SELECT_VALIDATE
@ BMO_OPTYPE_FLAG_UNTAN_MULTIRES
void * BLI_mempool_calloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
void bmesh_edit_begin(BMesh *, BMOpTypeFlag)
BMesh Begin Edit.
void * BLI_mempool_alloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
void BM_mesh_elem_table_init(BMesh *bm, const char htype)
void BM_mesh_elem_table_free(BMesh *bm, const char htype)
void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag)
BMesh End Edit.
void BM_mesh_elem_index_ensure_ex(BMesh *bm, const char htype, int elem_offset[4])
BMesh * BM_mesh_create(const BMAllocTemplate *allocsize, const BMeshCreateParams *params)
BMesh Make Mesh.
void BM_mesh_elem_toolflags_clear(BMesh *bm)
void * BLI_mempool_findelem(BLI_mempool *pool, unsigned int index) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void bpy_bm_generic_invalidate(struct BPy_BMGeneric *)
int BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len)
Iterator as Array.
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const uint *face_idx)
void BM_mesh_normals_update(BMesh *bm)
BMEdge * BM_edge_at_index_find_or_table(BMesh *bm, const int index)
bool BM_mesh_elem_table_check(BMesh *bm)
struct BMFlagLayer * oflags
struct BMFlagLayer * oflags
struct BMLoop * next
struct BMLoop * prev
struct BMLoop * radial_prev
struct BMEdge * e
struct BMVert * v
struct BMLoop * radial_next
struct BMFace * f
struct BMFlagLayer * oflags
struct BMEdge * e
struct MLoopNorSpaceArray * lnor_spacearr
ListBaseT< BMEditSelection > selected
struct BLI_mempool * pool