code cleanup: change C naming convention (so py and C api match), eg:
[blender.git] / 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 }