source/blender/bmesh/intern/bmesh_mesh.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Geoffrey Bantle.
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file blender/bmesh/intern/bmesh_mesh.c
  24  *  \ingroup bmesh
  25  *
  26  * BM mesh level functions.
  27  */
  28
  29 #include "MEM_guardedalloc.h"
  30
  31 #include "DNA_listBase.h"
  32 #include "DNA_object_types.h"
  33
  34 #include "BLI_listbase.h"
  35 #include "BLI_math.h"
  36 #include "BLI_utildefines.h"
  37
  38 #include "BKE_cdderivedmesh.h"
  39 #include "BKE_tessmesh.h"
  40 #include "BKE_multires.h"
  41
  42 #include "ED_mesh.h"
  43
  44 #include "intern/bmesh_private.h"
  45
  46 /* used as an extern, defined in bmesh.h */
  47 BMAllocTemplate bm_mesh_allocsize_default = {512, 1024, 2048, 512};
  48 BMAllocTemplate bm_mesh_chunksize_default = {512, 1024, 2048, 512};
  49
  50 static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize)
  51 {
  52         bm->vpool = BLI_mempool_create(sizeof(BMVert), allocsize->totvert, bm_mesh_chunksize_default.totvert, BLI_MEMPOOL_ALLOW_ITER);
  53         bm->epool = BLI_mempool_create(sizeof(BMEdge), allocsize->totedge, bm_mesh_chunksize_default.totedge, BLI_MEMPOOL_ALLOW_ITER);
  54         bm->lpool = BLI_mempool_create(sizeof(BMLoop), allocsize->totloop, bm_mesh_chunksize_default.totloop, 0);
  55         bm->fpool = BLI_mempool_create(sizeof(BMFace), allocsize->totface, bm_mesh_chunksize_default.totface, BLI_MEMPOOL_ALLOW_ITER);
  56
  57 #ifdef USE_BMESH_HOLES
  58         bm->looplistpool = BLI_mempool_create(sizeof(BMLoopList), allocsize[3], allocsize[3], FALSE, FALSE);
  59 #endif
  60
  61         /* allocate one flag pool that we don't get rid of. */
  62         bm->toolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), 512, 512, 0);
  63 }
  64
  65 /**
  66  * \brief BMesh Make Mesh
  67  *
  68  * Allocates a new BMesh structure.
  69  *
  70  * \return The New bmesh
  71  *
  72  * \note ob is needed by multires
  73  */
  74 BMesh *BM_mesh_create(BMAllocTemplate *allocsize)
  75 {
  76         /* allocate the structure */
  77         BMesh *bm = MEM_callocN(sizeof(BMesh), __func__);
  78
  79         /* allocate the memory pools for the mesh elements */
  80         bm_mempool_init(bm, allocsize);
  81
  82         /* allocate one flag pool that we don't get rid of. */
  83         bm->stackdepth = 1;
  84         bm->totflags = 1;
  85
  86         return bm;
  87 }
  88
  89 /**
  90  * \brief BMesh Free Mesh Data
  91  *
  92  *      Frees a BMesh structure.
  93  *
  94  * \note frees mesh, but not actual BMesh struct
  95  */
  96 void BM_mesh_data_free(BMesh *bm)
  97 {
  98         BMVert *v;
  99         BMEdge *e;
 100         BMLoop *l;
 101         BMFace *f;
 102
 103
 104         BMIter iter;
 105         BMIter itersub;
 106
 107         BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 108                 CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data));
 109         }
 110         BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 111                 CustomData_bmesh_free_block(&(bm->edata), &(e->head.data));
 112         }
 113         BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
 114                 CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data));
 115                 BM_ITER_ELEM (l, &itersub, f, BM_LOOPS_OF_FACE) {
 116                         CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data));
 117                 }
 118         }
 119
 120         /* Free custom data pools, This should probably go in CustomData_free? */
 121         if (bm->vdata.totlayer) BLI_mempool_destroy(bm->vdata.pool);
 122         if (bm->edata.totlayer) BLI_mempool_destroy(bm->edata.pool);
 123         if (bm->ldata.totlayer) BLI_mempool_destroy(bm->ldata.pool);
 124         if (bm->pdata.totlayer) BLI_mempool_destroy(bm->pdata.pool);
 125
 126         /* free custom data */
 127         CustomData_free(&bm->vdata, 0);
 128         CustomData_free(&bm->edata, 0);
 129         CustomData_free(&bm->ldata, 0);
 130         CustomData_free(&bm->pdata, 0);
 131
 132         /* destroy element pools */
 133         BLI_mempool_destroy(bm->vpool);
 134         BLI_mempool_destroy(bm->epool);
 135         BLI_mempool_destroy(bm->lpool);
 136         BLI_mempool_destroy(bm->fpool);
 137
 138         /* destroy flag pool */
 139         BLI_mempool_destroy(bm->toolflagpool);
 140
 141 #ifdef USE_BMESH_HOLES
 142         BLI_mempool_destroy(bm->looplistpool);
 143 #endif
 144
 145         /* These tables aren't used yet, so it's not strictly necessary
 146          * to 'end' them (with 'e' param) but if someone tries to start
 147          * using them, having these in place will save a lot of pain */
 148         mesh_octree_table(NULL, NULL, NULL, 'e');
 149         mesh_mirrtopo_table(NULL, 'e');
 150
 151         BLI_freelistN(&bm->selected);
 152
 153         BMO_error_clear(bm);
 154 }
 155
 156 /**
 157  * \brief BMesh Clear Mesh
 158  *
 159  * Clear all data in bm
 160  */
 161 void BM_mesh_clear(BMesh *bm)
 162 {
 163         /* free old mesh */
 164         BM_mesh_data_free(bm);
 165         memset(bm, 0, sizeof(BMesh));
 166
 167         /* allocate the memory pools for the mesh elements */
 168         bm_mempool_init(bm, &bm_mesh_allocsize_default);
 169
 170         bm->stackdepth = 1;
 171         bm->totflags = 1;
 172 }
 173
 174 /**
 175  * \brief BMesh Free Mesh
 176  *
 177  *      Frees a BMesh data and its structure.
 178  */
 179 void BM_mesh_free(BMesh *bm)
 180 {
 181         BM_mesh_data_free(bm);
 182
 183         if (bm->py_handle) {
 184                 /* keep this out of 'BM_mesh_data_free' because we wan't python
 185                  * to be able to clear the mesh and maintain access. */
 186                 extern void bpy_bm_generic_invalidate(void *self);
 187
 188                 bpy_bm_generic_invalidate(bm->py_handle);
 189                 bm->py_handle = NULL;
 190         }
 191
 192         MEM_freeN(bm);
 193 }
 194
 195 /**
 196  * \brief BMesh Compute Normals
 197  *
 198  * Updates the normals of a mesh.
 199  */
 200 void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 201 {
 202         BMVert *v;
 203         BMFace *f;
 204         BMLoop *l;
 205         BMEdge *e;
 206         BMIter verts;
 207         BMIter faces;
 208         BMIter loops;
 209         BMIter edges;
 210         int index;
 211         float (*edgevec)[3];
 212
 213         /* calculate all face normals */
 214         BM_ITER_MESH (f, &faces, bm, BM_FACES_OF_MESH) {
 215                 if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
 216                         continue;
 217 #if 0   /* UNUSED */
 218                 if (f->head.flag & BM_NONORMCALC)
 219                         continue;
 220 #endif
 221
 222                 BM_face_normal_update(f);
 223         }
 224
 225         /* Zero out vertex normals */
 226         BM_ITER_MESH (v, &verts, bm, BM_VERTS_OF_MESH) {
 227                 if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
 228                         continue;
 229
 230                 zero_v3(v->no);
 231         }
 232
 233         /* compute normalized direction vectors for each edge. directions will be
 234          * used below for calculating the weights of the face normals on the vertex
 235          * normals */
 236         index = 0;
 237         edgevec = MEM_callocN(sizeof(float) * 3 * bm->totedge, "BM normal computation array");
 238         BM_ITER_MESH (e, &edges, bm, BM_EDGES_OF_MESH) {
 239                 BM_elem_index_set(e, index); /* set_inline */
 240
 241                 if (e->l) {
 242                         sub_v3_v3v3(edgevec[index], e->v2->co, e->v1->co);
 243                         normalize_v3(edgevec[index]);
 244                 }
 245                 else {
 246                         /* the edge vector will not be needed when the edge has no radial */
 247                 }
 248
 249                 index++;
 250         }
 251         bm->elem_index_dirty &= ~BM_EDGE;
 252
 253         /* add weighted face normals to vertices */
 254         BM_ITER_MESH (f, &faces, bm, BM_FACES_OF_MESH) {
 255
 256                 if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
 257                         continue;
 258
 259                 BM_ITER_ELEM (l, &loops, f, BM_LOOPS_OF_FACE) {
 260                         float *e1diff, *e2diff;
 261                         float dotprod;
 262                         float fac;
 263
 264                         /* calculate the dot product of the two edges that
 265                          * meet at the loop's vertex */
 266                         e1diff = edgevec[BM_elem_index_get(l->prev->e)];
 267                         e2diff = edgevec[BM_elem_index_get(l->e)];
 268                         dotprod = dot_v3v3(e1diff, e2diff);
 269
 270                         /* edge vectors are calculated from e->v1 to e->v2, so
 271                          * adjust the dot product if one but not both loops
 272                          * actually runs from from e->v2 to e->v1 */
 273                         if ((l->prev->e->v1 == l->prev->v) ^ (l->e->v1 == l->v)) {
 274                                 dotprod = -dotprod;
 275                         }
 276
 277                         fac = saacos(-dotprod);
 278
 279                         /* accumulate weighted face normal into the vertex's normal */
 280                         madd_v3_v3fl(l->v->no, f->no, fac);
 281                 }
 282         }
 283
 284         /* normalize the accumulated vertex normals */
 285         BM_ITER_MESH (v, &verts, bm, BM_VERTS_OF_MESH) {
 286                 if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
 287                         continue;
 288
 289                 if (normalize_v3(v->no) == 0.0f) {
 290                         normalize_v3_v3(v->no, v->co);
 291                 }
 292         }
 293
 294         MEM_freeN(edgevec);
 295 }
 296
 297 /*
 298  * This function ensures correct normals for the mesh, but
 299  * sets the flag BM_ELEM_TAG in flipped faces, to allow restoration
 300  * of original normals.
 301  *
 302  * if undo is 0: calculate right normals
 303  * if undo is 1: restore original normals
 304  */
 305
 306 //keep in sycn with utils.c!
 307 #define FACE_FLIP   8
 308 static void bm_rationalize_normals(BMesh *bm, int undo)
 309 {
 310         BMOperator bmop;
 311         BMFace *f;
 312         BMIter iter;
 313
 314         if (undo) {
 315                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
 316                         if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
 317                                 BM_face_normal_flip(bm, f);
 318                         }
 319                         BM_elem_flag_disable(f, BM_ELEM_TAG);
 320                 }
 321
 322                 return;
 323         }
 324
 325         BMO_op_initf(bm, &bmop, "righthandfaces faces=%af do_flip=%b", FALSE);
 326
 327         BMO_push(bm, &bmop);
 328         bmo_righthandfaces_exec(bm, &bmop);
 329
 330         BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
 331                 BM_elem_flag_set(f, BM_ELEM_TAG, BMO_elem_flag_test(bm, f, FACE_FLIP));
 332         }
 333
 334         BMO_pop(bm);
 335         BMO_op_finish(bm, &bmop);
 336 }
 337
 338 static void UNUSED_FUNCTION(bm_mdisps_space_set)(Object *ob, BMesh *bm, int from, int to)
 339 {
 340         /* switch multires data out of tangent space */
 341         if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
 342                 BMEditMesh *em = BMEdit_Create(bm, FALSE);
 343                 DerivedMesh *dm = CDDM_from_BMEditMesh(em, NULL, TRUE, FALSE);
 344                 MDisps *mdisps;
 345                 BMFace *f;
 346                 BMIter iter;
 347                 // int i = 0; // UNUSED
 348
 349                 multires_set_space(dm, ob, from, to);
 350
 351                 mdisps = CustomData_get_layer(&dm->loopData, CD_MDISPS);
 352
 353                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
 354                         BMLoop *l;
 355                         BMIter liter;
 356                         BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
 357                                 MDisps *lmd = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
 358
 359                                 if (!lmd->disps) {
 360                                         printf("%s: warning - 'lmd->disps' == NULL\n", __func__);
 361                                 }
 362
 363                                 if (lmd->disps && lmd->totdisp == mdisps->totdisp) {
 364                                         memcpy(lmd->disps, mdisps->disps, sizeof(float) * 3 * lmd->totdisp);
 365                                 }
 366                                 else if (mdisps->disps) {
 367                                         if (lmd->disps)
 368                                                 MEM_freeN(lmd->disps);
 369
 370                                         lmd->disps = MEM_dupallocN(mdisps->disps);
 371                                         lmd->totdisp = mdisps->totdisp;
 372                                         lmd->level = mdisps->level;
 373                                 }
 374
 375                                 mdisps++;
 376                                 // i += 1;
 377                         }
 378                 }
 379
 380                 dm->needsFree = 1;
 381                 dm->release(dm);
 382
 383                 /* setting this to NULL prevents BMEdit_Free from freeing it */
 384                 em->bm = NULL;
 385                 BMEdit_Free(em);
 386                 MEM_freeN(em);
 387         }
 388 }
 389
 390 /**
 391  * \brief BMesh Begin Edit
 392  *
 393  * Functions for setting up a mesh for editing and cleaning up after
 394  * the editing operations are done. These are called by the tools/operator
 395  * API for each time a tool is executed.
 396  */
 397 void bmesh_edit_begin(BMesh *bm, int flag)
 398 {
 399         bm->opflag = flag;
 400
 401         /* Most operators seem to be using BMO_OP_FLAG_UNTAN_MULTIRES to change the MDisps to
 402          * absolute space during mesh edits. With this enabled, changes to the topology
 403          * (loop cuts, edge subdivides, etc) are not reflected in the higher levels of
 404          * the mesh at all, which doesn't seem right. Turning off completely for now,
 405          * until this is shown to be better for certain types of mesh edits. */
 406 #if BMOP_UNTAN_MULTIRES_ENABLED
 407         /* switch multires data out of tangent space */
 408         if ((flag & BMO_OP_FLAG_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
 409                 bmesh_mdisps_space_set(bm, MULTIRES_SPACE_TANGENT, MULTIRES_SPACE_ABSOLUTE);
 410
 411                 /* ensure correct normals, if possible */
 412                 bmesh_rationalize_normals(bm, 0);
 413                 BM_mesh_normals_update(bm);
 414         }
 415         else if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) {
 416                 bmesh_rationalize_normals(bm, 0);
 417         }
 418 #else
 419         if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) {
 420                 bm_rationalize_normals(bm, 0);
 421         }
 422 #endif
 423 }
 424
 425 /**
 426  * \brief BMesh End Edit
 427  */
 428 void bmesh_edit_end(BMesh *bm, int flag)
 429 {
 430         /* BMO_OP_FLAG_UNTAN_MULTIRES disabled for now, see comment above in bmesh_edit_begin. */
 431 #if BMOP_UNTAN_MULTIRES_ENABLED
 432         /* switch multires data into tangent space */
 433         if ((flag & BMO_OP_FLAG_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
 434                 /* set normals to their previous winding */
 435                 bmesh_rationalize_normals(bm, 1);
 436                 bmesh_mdisps_space_set(bm, MULTIRES_SPACE_ABSOLUTE, MULTIRES_SPACE_TANGENT);
 437         }
 438         else if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) {
 439                 bmesh_rationalize_normals(bm, 1);
 440         }
 441 #else
 442         if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) {
 443                 bm_rationalize_normals(bm, 1);
 444         }
 445 #endif
 446
 447         bm->opflag = 0;
 448
 449         /* compute normals, clear temp flags and flush selections */
 450         BM_mesh_normals_update(bm, TRUE);
 451         BM_mesh_select_mode_flush(bm);
 452 }
 453
 454 void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
 455 {
 456         BMIter iter;
 457         BMElem *ele;
 458
 459 #ifdef DEBUG
 460         BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__);
 461 #endif
 462
 463         if (hflag & BM_VERT) {
 464                 if (bm->elem_index_dirty & BM_VERT) {
 465                         int index = 0;
 466                         BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
 467                                 BM_elem_index_set(ele, index); /* set_ok */
 468                                 index++;
 469                         }
 470                         bm->elem_index_dirty &= ~BM_VERT;
 471                         BLI_assert(index == bm->totvert);
 472                 }
 473                 else {
 474                         // printf("%s: skipping vert index calc!\n", __func__);
 475                 }
 476         }
 477
 478         if (hflag & BM_EDGE) {
 479                 if (bm->elem_index_dirty & BM_EDGE) {
 480                         int index = 0;
 481                         BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
 482                                 BM_elem_index_set(ele, index); /* set_ok */
 483                                 index++;
 484                         }
 485                         bm->elem_index_dirty &= ~BM_EDGE;
 486                         BLI_assert(index == bm->totedge);
 487                 }
 488                 else {
 489                         // printf("%s: skipping edge index calc!\n", __func__);
 490                 }
 491         }
 492
 493         if (hflag & BM_FACE) {
 494                 if (bm->elem_index_dirty & BM_FACE) {
 495                         int index = 0;
 496                         BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
 497                                 BM_elem_index_set(ele, index); /* set_ok */
 498                                 index++;
 499                         }
 500                         bm->elem_index_dirty &= ~BM_FACE;
 501                         BLI_assert(index == bm->totface);
 502                 }
 503                 else {
 504                         // printf("%s: skipping face index calc!\n", __func__);
 505                 }
 506         }
 507 }
 508
 509
 510 /**
 511  * Array checking/setting macros
 512  *
 513  * Currently vert/edge/loop/face index data is being abused, in a few areas of the code.
 514  *
 515  * To avoid correcting them afterwards, set 'bm->elem_index_dirty' however its possible
 516  * this flag is set incorrectly which could crash blender.
 517  *
 518  * These functions ensure its correct and are called more often in debug mode.
 519  */
 520
 521 void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *func,
 522                                  const char *msg_a, const char *msg_b)
 523 {
 524         const char iter_types[3] = {BM_VERTS_OF_MESH,
 525                                     BM_EDGES_OF_MESH,
 526                                     BM_FACES_OF_MESH};
 527
 528         const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
 529         const char *type_names[3] = {"vert", "edge", "face"};
 530
 531         BMIter iter;
 532         BMElem *ele;
 533         int i;
 534         int is_any_error = 0;
 535
 536         for (i = 0; i < 3; i++) {
 537                 const int is_dirty = (flag_types[i] & bm->elem_index_dirty);
 538                 int index = 0;
 539                 int is_error = FALSE;
 540                 int err_val = 0;
 541                 int err_idx = 0;
 542
 543                 BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
 544                         if (!is_dirty) {
 545                                 if (BM_elem_index_get(ele) != index) {
 546                                         err_val = BM_elem_index_get(ele);
 547                                         err_idx = index;
 548                                         is_error = TRUE;
 549                                 }
 550                         }
 551
 552                         BM_elem_index_set(ele, index); /* set_ok */
 553                         index++;
 554                 }
 555
 556                 if ((is_error == TRUE) && (is_dirty == FALSE)) {
 557                         is_any_error = TRUE;
 558                         fprintf(stderr,
 559                                 "Invalid Index: at %s, %s, %s[%d] invalid index %d, '%s', '%s'\n",
 560                                 location, func, type_names[i], err_idx, err_val, msg_a, msg_b);
 561                 }
 562                 else if ((is_error == FALSE) && (is_dirty == TRUE)) {
 563
 564 #if 0       /* mostly annoying */
 565
 566                         /* dirty may have been incorrectly set */
 567                         fprintf(stderr,
 568                                 "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are correct, '%s', '%s'\n",
 569                                 location, func, type_names[i], msg_a, msg_b);
 570 #endif
 571                 }
 572         }
 573
 574 #if 0 /* mostly annoying, even in debug mode */
 575 #ifdef DEBUG
 576         if (is_any_error == 0) {
 577                 fprintf(stderr,
 578                         "Valid Index Success: at %s, %s, '%s', '%s'\n",
 579                         location, func, msg_a, msg_b);
 580         }
 581 #endif
 582 #endif
 583         (void) is_any_error; /* shut up the compiler */
 584
 585 }
 586
 587 /**
 588  * Return the amount of element of type 'type' in a given bmesh.
 589  */
 590 int BM_mesh_elem_count(BMesh *bm, const char htype)
 591 {
 592         if (htype == BM_VERT) return bm->totvert;
 593         else if (htype == BM_EDGE) return bm->totedge;
 594         else if (htype == BM_FACE) return bm->totface;
 595
 596         return 0;
 597 }
 598
 599 /**
 600  * Remaps the vertices, edges and/or faces of the bmesh as indicated by vert/edge/face_idx arrays
 601  * (xxx_idx[org_index] = new_index).
 602  *
 603  * A NULL array means no changes.
 604  *
 605  * Note: - Does not mess with indices, just sets elem_index_dirty flag.
 606  *       - For verts/edges/faces only (as loops must remain "ordered" and "aligned"
 607  *         on a per-face basis...).
 608  *
 609  * WARNING: Be careful if you keep pointers to affected BM elements, or arrays, when using this func!
 610  */
 611 void BM_mesh_remap(BMesh *bm, int *vert_idx, int *edge_idx, int *face_idx)
 612 {
 613         /* Mapping old to new pointers. */
 614         GHash *vptr_map = NULL, *eptr_map = NULL, *fptr_map = NULL;
 615         BMIter iter, iterl;
 616         BMVert *ve;
 617         BMEdge *ed;
 618         BMFace *fa;
 619         BMLoop *lo;
 620
 621         if (!(vert_idx || edge_idx || face_idx))
 622                 return;
 623
 624         /* Remap vertices */
 625         if (vert_idx) {
 626                 BMVert **verts_pool, *verts_copy, **vep;
 627                 int i, totvert = bm->totvert;
 628                 int *new_idx = NULL;
 629
 630                 /* Init the old-to-new vert pointers mapping */
 631                 vptr_map = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "BM_mesh_remap vert pointers mapping");
 632
 633                 /* Make a copy of all vertices. */
 634                 verts_pool = MEM_callocN(sizeof(BMVert *) * totvert, "BM_mesh_remap verts pool");
 635                 BM_iter_as_array(bm, BM_VERTS_OF_MESH, NULL, (void **)verts_pool, totvert);
 636                 verts_copy = MEM_mallocN(sizeof(BMVert) * totvert, "BM_mesh_remap verts copy");
 637                 for (i = totvert, ve = verts_copy + totvert - 1, vep = verts_pool + totvert - 1; i--; ve--, vep--) {
 638                         *ve = **vep;
 639 /*                      printf("*vep: %p, verts_pool[%d]: %p\n", *vep, i, verts_pool[i]);*/
 640                 }
 641
 642                 /* Copy back verts to their new place, and update old2new pointers mapping. */
 643                 new_idx = vert_idx + totvert - 1;
 644                 ve = verts_copy + totvert - 1;
 645                 vep = verts_pool + totvert - 1; /* old, org pointer */
 646                 for (i = totvert; i--; new_idx--, ve--, vep--) {
 647                         BMVert *new_vep = verts_pool[*new_idx];
 648                         *new_vep = *ve;
 649 /*                      printf("mapping vert from %d to %d (%p/%p to %p)\n", i, *new_idx, *vep, verts_pool[i], new_vep);*/
 650                         BLI_ghash_insert(vptr_map, (void *)*vep, (void *)new_vep);
 651                 }
 652                 bm->elem_index_dirty |= BM_VERT;
 653
 654                 MEM_freeN(verts_pool);
 655                 MEM_freeN(verts_copy);
 656         }
 657
 658         /* XXX Code not tested yet (though I don't why it would fail)! */
 659         if (edge_idx) {
 660                 BMEdge **edges_pool, *edges_copy, **edp;
 661                 int i, totedge = bm->totedge;
 662                 int *new_idx = NULL;
 663
 664                 /* Init the old-to-new vert pointers mapping */
 665                 eptr_map = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "BM_mesh_remap edge pointers mapping");
 666
 667                 /* Make a copy of all vertices. */
 668                 edges_pool = MEM_callocN(sizeof(BMEdge *) * totedge, "BM_mesh_remap edges pool");
 669                 BM_iter_as_array(bm, BM_EDGES_OF_MESH, NULL, (void **)edges_pool, totedge);
 670                 edges_copy = MEM_mallocN(sizeof(BMEdge) * totedge, "BM_mesh_remap edges copy");
 671                 for (i = totedge, ed = edges_copy + totedge - 1, edp = edges_pool + totedge - 1; i--; ed--, edp--) {
 672                         *ed = **edp;
 673                 }
 674
 675                 /* Copy back verts to their new place, and update old2new pointers mapping. */
 676                 new_idx = edge_idx + totedge - 1;
 677                 ed = edges_copy + totedge - 1;
 678                 edp = edges_pool + totedge - 1; /* old, org pointer */
 679                 for (i = totedge; i--; new_idx--, ed--, edp--) {
 680                         BMEdge *new_edp = edges_pool[*new_idx];
 681                         *new_edp = *ed;
 682                         BLI_ghash_insert(eptr_map, (void *)*edp, (void *)new_edp);
 683                 }
 684
 685                 bm->elem_index_dirty |= BM_EDGE;
 686
 687                 MEM_freeN(edges_pool);
 688                 MEM_freeN(edges_copy);
 689         }
 690
 691         /* XXX Code not tested yet (though I don't why it would fail)! */
 692         if (face_idx) {
 693                 BMFace **faces_pool, *faces_copy, **fap;
 694                 int i, totface = bm->totface;
 695                 int *new_idx = NULL;
 696
 697                 /* Init the old-to-new vert pointers mapping */
 698                 fptr_map = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "BM_mesh_remap face pointers mapping");
 699
 700                 /* Make a copy of all vertices. */
 701                 faces_pool = MEM_callocN(sizeof(BMFace *) * totface, "BM_mesh_remap faces pool");
 702                 BM_iter_as_array(bm, BM_FACES_OF_MESH, NULL, (void **)faces_pool, totface);
 703                 faces_copy = MEM_mallocN(sizeof(BMFace) * totface, "BM_mesh_remap faces copy");
 704                 for (i = totface, fa = faces_copy + totface - 1, fap = faces_pool + totface - 1; i--; fa--, fap--) {
 705                         *fa = **fap;
 706                 }
 707
 708                 /* Copy back verts to their new place, and update old2new pointers mapping. */
 709                 new_idx = face_idx + totface - 1;
 710                 fa = faces_copy + totface - 1;
 711                 fap = faces_pool + totface - 1; /* old, org pointer */
 712                 for (i = totface; i--; new_idx--, fa--, fap--) {
 713                         BMFace *new_fap = faces_pool[*new_idx];
 714                         *new_fap = *fa;
 715                         BLI_ghash_insert(fptr_map, (void *)*fap, (void *)new_fap);
 716                 }
 717
 718                 bm->elem_index_dirty |= BM_FACE;
 719
 720                 MEM_freeN(faces_pool);
 721                 MEM_freeN(faces_copy);
 722         }
 723
 724         /* And now, fix all vertices/edges/faces/loops pointers! */
 725         /* Verts' pointers, only edge pointers... */
 726         if (eptr_map) {
 727                 BM_ITER_MESH (ve, &iter, bm, BM_VERTS_OF_MESH) {
 728 /*                      printf("Vert e: %p -> %p\n", ve->e, BLI_ghash_lookup(eptr_map, (const void*)ve->e));*/
 729                         ve->e = BLI_ghash_lookup(eptr_map, (const void *)ve->e);
 730                 }
 731         }
 732
 733         /* Edges' pointers, only vert pointers (as we don't mess with loops!)... */
 734         if (vptr_map) {
 735                 BM_ITER_MESH (ed, &iter, bm, BM_EDGES_OF_MESH) {
 736 /*                      printf("Edge v1: %p -> %p\n", ed->v1, BLI_ghash_lookup(vptr_map, (const void*)ed->v1));*/
 737 /*                      printf("Edge v2: %p -> %p\n", ed->v2, BLI_ghash_lookup(vptr_map, (const void*)ed->v2));*/
 738                         ed->v1 = BLI_ghash_lookup(vptr_map, (const void *)ed->v1);
 739                         ed->v2 = BLI_ghash_lookup(vptr_map, (const void *)ed->v2);
 740                 }
 741         }
 742
 743         /* Faces' pointers (loops, in fact), always needed... */
 744         BM_ITER_MESH (fa, &iter, bm, BM_FACES_OF_MESH) {
 745                 BM_ITER_ELEM (lo, &iterl, fa, BM_LOOPS_OF_FACE) {
 746                         if (vptr_map) {
 747 /*                              printf("Loop v: %p -> %p\n", lo->v, BLI_ghash_lookup(vptr_map, (const void*)lo->v));*/
 748                                 lo->v = BLI_ghash_lookup(vptr_map, (const void *)lo->v);
 749                         }
 750                         if (eptr_map) {
 751 /*                              printf("Loop e: %p -> %p\n", lo->e, BLI_ghash_lookup(eptr_map, (const void*)lo->e));*/
 752                                 lo->e = BLI_ghash_lookup(eptr_map, (const void *)lo->e);
 753                         }
 754                         if (fptr_map) {
 755 /*                              printf("Loop f: %p -> %p\n", lo->f, BLI_ghash_lookup(fptr_map, (const void*)lo->f));*/
 756                                 lo->f = BLI_ghash_lookup(fptr_map, (const void *)lo->f);
 757                         }
 758                 }
 759         }
 760
 761         if (vptr_map)
 762                 BLI_ghash_free(vptr_map, NULL, NULL);
 763         if (eptr_map)
 764                 BLI_ghash_free(eptr_map, NULL, NULL);
 765         if (fptr_map)
 766                 BLI_ghash_free(fptr_map, NULL, NULL);
 767 }
 768
 769 BMVert *BM_vert_at_index(BMesh *bm, const int index)
 770 {
 771         return BLI_mempool_findelem(bm->vpool, index);
 772 }
 773
 774 BMEdge *BM_edge_at_index(BMesh *bm, const int index)
 775 {
 776         return BLI_mempool_findelem(bm->epool, index);
 777 }
 778
 779 BMFace *BM_face_at_index(BMesh *bm, const int index)
 780 {
 781         return BLI_mempool_findelem(bm->fpool, index);
 782 }