Merge branch 'master' into blender2.8
[blender.git] / source / blender / bmesh / intern / bmesh_mesh_conv.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_conv.c
24  *  \ingroup bmesh
25  *
26  * BM mesh conversion functions.
27  *
28  * \section bm_mesh_conv_shapekey Converting Shape Keys
29  *
30  * When converting to/from a Mesh/BMesh you can optionally pass a shape key to edit.
31  * This has the effect of editing the shape key-block rather then the original mesh vertex coords
32  * (although additional geometry is still allowed and uses fallback locations on converting).
33  *
34  * While this works for any mesh/bmesh this is made use of by entering and exiting edit-mode.
35  *
36  * There are comments in code but this should help explain the general
37  * intention as to how this works converting from/to bmesh.
38  *
39  *
40  * \subsection user_pov User Perspective
41  *
42  * - Editmode operations when a shape key-block is active edits only that key-block.
43  * - The first Basis key-block always matches the Mesh verts.
44  * - Changing vertex locations of _any_ Basis will apply offsets to those shape keys using this as their Basis.
45  *
46  *
47  * \subsection enter_editmode Entering EditMode - #BM_mesh_bm_from_me
48  *
49  * - the active key-block is used for BMesh vertex locations on entering edit-mode.
50  * So obviously the meshes vertex locations remain unchanged and the shape key its self is not being edited directly.
51  * Simply the #BMVert.co is a initialized from active shape key (when its set).
52  * - all key-blocks are added as CustomData layers (read code for details).
53  *
54  *
55  * \subsection exit_editmode Exiting EditMode - #BM_mesh_bm_to_me
56  *
57  * This is where the most confusing code is! Won't attempt to document the details here, for that read the code.
58  * But basics are as follows.
59  *
60  * - Vertex locations (possibly modified from initial active key-block) are copied directly into #MVert.co
61  * (special confusing note that these may be restored later, when editing the 'Basis', read on).
62  * - if the 'Key' is relative, and the active key-block is the basis for ANY other key-blocks - get an array of offsets
63  * between the new vertex locations and the original shape key (before entering edit-mode),
64  * these offsets get applied later on to inactive key-blocks using the active one (which we are editing) as their Basis.
65  *
66  * Copying the locations back to the shape keys is quite confusing...
67  * One main area of confusion is that when editing a 'Basis' key-block 'me->key->refkey'
68  * The coords are written into the mesh, from the users perspective the Basis coords are written into the mesh
69  * when exiting edit-mode.
70  *
71  * When _not_ editing the 'Basis', the original vertex locations (stored in the mesh and unchanged during edit-mode),
72  * are copied back into the mesh.
73  *
74  * This has the effect from the users POV of leaving the mesh un-touched, and only editing the active shape key-block.
75  *
76  */
77
78 #include "DNA_mesh_types.h"
79 #include "DNA_meshdata_types.h"
80 #include "DNA_object_types.h"
81 #include "DNA_modifier_types.h"
82 #include "DNA_key_types.h"
83
84 #include "MEM_guardedalloc.h"
85
86 #include "BLI_listbase.h"
87 #include "BLI_alloca.h"
88 #include "BLI_math_vector.h"
89
90 #include "BKE_mesh.h"
91 #include "BKE_customdata.h"
92 #include "BKE_multires.h"
93
94 #include "BKE_global.h" /* ugh - for looping over all objects */
95 #include "BKE_main.h"
96 #include "BKE_key.h"
97
98 #include "bmesh.h"
99 #include "intern/bmesh_private.h" /* for element checking */
100
101 void BM_mesh_cd_flag_ensure(BMesh *bm, Mesh *mesh, const char cd_flag)
102 {
103         const char cd_flag_all = BM_mesh_cd_flag_from_bmesh(bm) | cd_flag;
104         BM_mesh_cd_flag_apply(bm, cd_flag_all);
105         if (mesh) {
106                 mesh->cd_flag = cd_flag_all;
107         }
108 }
109
110 void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag)
111 {
112         /* CustomData_bmesh_init_pool() must run first */
113         BLI_assert(bm->vdata.totlayer == 0 || bm->vdata.pool != NULL);
114         BLI_assert(bm->edata.totlayer == 0 || bm->edata.pool != NULL);
115         BLI_assert(bm->pdata.totlayer == 0 || bm->pdata.pool != NULL);
116
117         if (cd_flag & ME_CDFLAG_VERT_BWEIGHT) {
118                 if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
119                         BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);
120                 }
121         }
122         else {
123                 if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
124                         BM_data_layer_free(bm, &bm->vdata, CD_BWEIGHT);
125                 }
126         }
127
128         if (cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {
129                 if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
130                         BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);
131                 }
132         }
133         else {
134                 if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
135                         BM_data_layer_free(bm, &bm->edata, CD_BWEIGHT);
136                 }
137         }
138
139         if (cd_flag & ME_CDFLAG_EDGE_CREASE) {
140                 if (!CustomData_has_layer(&bm->edata, CD_CREASE)) {
141                         BM_data_layer_add(bm, &bm->edata, CD_CREASE);
142                 }
143         }
144         else {
145                 if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
146                         BM_data_layer_free(bm, &bm->edata, CD_CREASE);
147                 }
148         }
149 }
150
151 char BM_mesh_cd_flag_from_bmesh(BMesh *bm)
152 {
153         char cd_flag = 0;
154         if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
155                 cd_flag |= ME_CDFLAG_VERT_BWEIGHT;
156         }
157         if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
158                 cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
159         }
160         if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
161                 cd_flag |= ME_CDFLAG_EDGE_CREASE;
162         }
163         return cd_flag;
164 }
165
166 /* Static function for alloc (duplicate in modifiers_bmesh.c) */
167 static BMFace *bm_face_create_from_mpoly(
168         MPoly *mp, MLoop *ml,
169         BMesh *bm, BMVert **vtable, BMEdge **etable)
170 {
171         BMVert **verts = BLI_array_alloca(verts, mp->totloop);
172         BMEdge **edges = BLI_array_alloca(edges, mp->totloop);
173         int j;
174
175         for (j = 0; j < mp->totloop; j++, ml++) {
176                 verts[j] = vtable[ml->v];
177                 edges[j] = etable[ml->e];
178         }
179
180         return BM_face_create(bm, verts, edges, mp->totloop, NULL, BM_CREATE_SKIP_CD);
181 }
182
183
184 /**
185  * \brief Mesh -> BMesh
186  * \param bm: The mesh to write into, while this is typically a newly created BMesh,
187  * merging into existing data is supported.
188  * Note the custom-data layout isn't used.
189  * If more comprehensive merging is needed we should move this into a separate function
190  * since this should be kept fast for edit-mode switching and storing undo steps.
191  *
192  * \warning This function doesn't calculate face normals.
193  */
194 void BM_mesh_bm_from_me(
195         BMesh *bm, Mesh *me,
196         const struct BMeshFromMeshParams *params)
197 {
198         const bool is_new =
199                 !(bm->totvert ||
200                   (bm->vdata.totlayer || bm->edata.totlayer || bm->pdata.totlayer || bm->ldata.totlayer));
201         MVert *mvert;
202         MEdge *medge;
203         MLoop *mloop;
204         MPoly *mp;
205         KeyBlock *actkey, *block;
206         BMVert *v, **vtable = NULL;
207         BMEdge *e, **etable = NULL;
208         BMFace *f, **ftable = NULL;
209         float (*keyco)[3] = NULL;
210         int totloops, i;
211
212         if (!me || !me->totvert) {
213                 if (me && is_new) { /*no verts? still copy customdata layout*/
214                         CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_ASSIGN, 0);
215                         CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_ASSIGN, 0);
216                         CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_ASSIGN, 0);
217                         CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_ASSIGN, 0);
218
219                         CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
220                         CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
221                         CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
222                         CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
223                 }
224                 return; /* sanity check */
225         }
226
227         if (is_new) {
228                 CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
229                 CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
230                 CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
231                 CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
232         }
233
234         /* -------------------------------------------------------------------- */
235         /* Shape Key */
236         int tot_shape_keys = me->key ? BLI_listbase_count(&me->key->block) : 0;
237         if (is_new == false) {
238                 tot_shape_keys = min_ii(tot_shape_keys, CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY));
239         }
240         const float (**shape_key_table)[3] = tot_shape_keys ? BLI_array_alloca(shape_key_table, tot_shape_keys) : NULL;
241
242         if ((params->active_shapekey != 0) && (me->key != NULL)) {
243                 actkey = BLI_findlink(&me->key->block, params->active_shapekey - 1);
244         }
245         else {
246                 actkey = NULL;
247         }
248
249         if (is_new) {
250                 if (tot_shape_keys || params->add_key_index) {
251                         CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
252                 }
253         }
254
255         if (tot_shape_keys) {
256                 if (is_new) {
257                         /* check if we need to generate unique ids for the shapekeys.
258                          * this also exists in the file reading code, but is here for
259                          * a sanity check */
260                         if (!me->key->uidgen) {
261                                 fprintf(stderr,
262                                         "%s had to generate shape key uid's in a situation we shouldn't need to! "
263                                         "(bmesh internal error)\n",
264                                         __func__);
265
266                                 me->key->uidgen = 1;
267                                 for (block = me->key->block.first; block; block = block->next) {
268                                         block->uid = me->key->uidgen++;
269                                 }
270                         }
271                 }
272
273                 if (actkey && actkey->totelem == me->totvert) {
274                         keyco = params->use_shapekey ? actkey->data : NULL;
275                         if (is_new) {
276                                 bm->shapenr = params->active_shapekey;
277                         }
278                 }
279
280                 for (i = 0, block = me->key->block.first; i < tot_shape_keys; block = block->next, i++) {
281                         if (is_new) {
282                                 CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
283                                                            CD_ASSIGN, NULL, 0, block->name);
284                                 int j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
285                                 bm->vdata.layers[j].uid = block->uid;
286                         }
287                         shape_key_table[i] = (const float (*)[3])block->data;
288                 }
289         }
290
291         if (is_new) {
292                 CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
293                 CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
294                 CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
295                 CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
296
297                 BM_mesh_cd_flag_apply(bm, me->cd_flag);
298         }
299
300         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
301         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
302         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
303         const int cd_shape_key_offset = me->key ? CustomData_get_offset(&bm->vdata, CD_SHAPEKEY) : -1;
304         const int cd_shape_keyindex_offset = is_new && (tot_shape_keys || params->add_key_index) ?
305                   CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX) : -1;
306
307         vtable = MEM_mallocN(sizeof(BMVert **) * me->totvert, __func__);
308
309         for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
310                 v = vtable[i] = BM_vert_create(bm, keyco ? keyco[i] : mvert->co, NULL, BM_CREATE_SKIP_CD);
311                 BM_elem_index_set(v, i); /* set_ok */
312
313                 /* transfer flag */
314                 v->head.hflag = BM_vert_flag_from_mflag(mvert->flag & ~SELECT);
315
316                 /* this is necessary for selection counts to work properly */
317                 if (mvert->flag & SELECT) {
318                         BM_vert_select_set(bm, v, true);
319                 }
320
321                 normal_short_to_float_v3(v->no, mvert->no);
322
323                 /* Copy Custom Data */
324                 CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data, true);
325
326                 if (cd_vert_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(v, cd_vert_bweight_offset, (float)mvert->bweight / 255.0f);
327
328                 /* set shape key original index */
329                 if (cd_shape_keyindex_offset != -1) BM_ELEM_CD_SET_INT(v, cd_shape_keyindex_offset, i);
330
331                 /* set shapekey data */
332                 if (tot_shape_keys) {
333                         float (*co_dst)[3] = BM_ELEM_CD_GET_VOID_P(v, cd_shape_key_offset);
334                         for (int j = 0; j < tot_shape_keys; j++, co_dst++) {
335                                 copy_v3_v3(*co_dst, shape_key_table[j][i]);
336                         }
337                 }
338         }
339         if (is_new) {
340                 bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
341         }
342
343         etable = MEM_mallocN(sizeof(BMEdge **) * me->totedge, __func__);
344
345         medge = me->medge;
346         for (i = 0; i < me->totedge; i++, medge++) {
347                 e = etable[i] = BM_edge_create(bm, vtable[medge->v1], vtable[medge->v2], NULL, BM_CREATE_SKIP_CD);
348                 BM_elem_index_set(e, i); /* set_ok */
349
350                 /* transfer flags */
351                 e->head.hflag = BM_edge_flag_from_mflag(medge->flag & ~SELECT);
352
353                 /* this is necessary for selection counts to work properly */
354                 if (medge->flag & SELECT) {
355                         BM_edge_select_set(bm, e, true);
356                 }
357
358                 /* Copy Custom Data */
359                 CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data, true);
360
361                 if (cd_edge_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_bweight_offset, (float)medge->bweight / 255.0f);
362                 if (cd_edge_crease_offset  != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_crease_offset,  (float)medge->crease  / 255.0f);
363
364         }
365         if (is_new) {
366                 bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
367         }
368
369         /* only needed for selection. */
370         if (me->mselect && me->totselect != 0) {
371                 ftable = MEM_mallocN(sizeof(BMFace **) * me->totpoly, __func__);
372         }
373
374         mloop = me->mloop;
375         mp = me->mpoly;
376         for (i = 0, totloops = 0; i < me->totpoly; i++, mp++) {
377                 BMLoop *l_iter;
378                 BMLoop *l_first;
379
380                 f = bm_face_create_from_mpoly(mp, mloop + mp->loopstart,
381                                               bm, vtable, etable);
382                 if (ftable != NULL) {
383                         ftable[i] = f;
384                 }
385
386                 if (UNLIKELY(f == NULL)) {
387                         printf("%s: Warning! Bad face in mesh"
388                                " \"%s\" at index %d!, skipping\n",
389                                __func__, me->id.name + 2, i);
390                         continue;
391                 }
392
393                 /* don't use 'i' since we may have skipped the face */
394                 BM_elem_index_set(f, bm->totface - 1); /* set_ok */
395
396                 /* transfer flag */
397                 f->head.hflag = BM_face_flag_from_mflag(mp->flag & ~ME_FACE_SEL);
398
399                 /* this is necessary for selection counts to work properly */
400                 if (mp->flag & ME_FACE_SEL) {
401                         BM_face_select_set(bm, f, true);
402                 }
403
404                 f->mat_nr = mp->mat_nr;
405                 if (i == me->act_face) bm->act_face = f;
406
407                 int j = mp->loopstart;
408                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
409                 do {
410                         /* don't use 'j' since we may have skipped some faces, hence some loops. */
411                         BM_elem_index_set(l_iter, totloops++); /* set_ok */
412
413                         /* Save index of correspsonding MLoop */
414                         CustomData_to_bmesh_block(&me->ldata, &bm->ldata, j++, &l_iter->head.data, true);
415                 } while ((l_iter = l_iter->next) != l_first);
416
417                 /* Copy Custom Data */
418                 CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data, true);
419
420                 if (params->calc_face_normal) {
421                         BM_face_normal_update(f);
422                 }
423         }
424         if (is_new) {
425                 bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP); /* added in order, clear dirty flag */
426         }
427
428         /* -------------------------------------------------------------------- */
429         /* MSelect clears the array elements (avoid adding multiple times).
430          *
431          * Take care to keep this last and not use (v/e/ftable) after this.
432          */
433
434         if (me->mselect && me->totselect != 0) {
435                 MSelect *msel;
436                 for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
437                         BMElem **ele_p;
438                         switch (msel->type) {
439                                 case ME_VSEL:
440                                         ele_p = (BMElem **)&vtable[msel->index];
441                                         break;
442                                 case ME_ESEL:
443                                         ele_p = (BMElem **)&etable[msel->index];
444                                         break;
445                                 case ME_FSEL:
446                                         ele_p = (BMElem **)&ftable[msel->index];
447                                         break;
448                                 default:
449                                         continue;
450                         }
451
452                         if (*ele_p != NULL) {
453                                 BM_select_history_store_notest(bm, *ele_p);
454                                 *ele_p = NULL;
455                         }
456                 }
457         }
458         else {
459                 BM_select_history_clear(bm);
460         }
461
462         MEM_freeN(vtable);
463         MEM_freeN(etable);
464         if (ftable) {
465                 MEM_freeN(ftable);
466         }
467 }
468
469
470 /**
471  * \brief BMesh -> Mesh
472  */
473 static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
474 {
475         const int cd_shape_keyindex_offset = CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX);
476         BMVert **vertMap = NULL;
477         BMVert *eve;
478         int i = 0;
479         BMIter iter;
480
481         /* caller needs to ensure this */
482         BLI_assert(ototvert > 0);
483
484         vertMap = MEM_callocN(sizeof(*vertMap) * ototvert, "vertMap");
485         if (cd_shape_keyindex_offset != -1) {
486                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
487                         const int keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
488                         if ((keyi != ORIGINDEX_NONE) &&
489                             (keyi < ototvert) &&
490                             /* not fool-proof, but chances are if we have many verts with the same index,
491                              * we will want to use the first one, since the second is more likely to be a duplicate. */
492                             (vertMap[keyi] == NULL))
493                         {
494                                 vertMap[keyi] = eve;
495                         }
496                 }
497         }
498         else {
499                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
500                         if (i < ototvert) {
501                                 vertMap[i] = eve;
502                         }
503                         else {
504                                 break;
505                         }
506                 }
507         }
508
509         return vertMap;
510 }
511
512 /**
513  * returns customdata shapekey index from a keyblock or -1
514  * \note could split this out into a more generic function */
515 static int bm_to_mesh_shape_layer_index_from_kb(BMesh *bm, KeyBlock *currkey)
516 {
517         int i;
518         int j = 0;
519
520         for (i = 0; i < bm->vdata.totlayer; i++) {
521                 if (bm->vdata.layers[i].type == CD_SHAPEKEY) {
522                         if (currkey->uid == bm->vdata.layers[i].uid) {
523                                 return j;
524                         }
525                         j++;
526                 }
527         }
528         return -1;
529 }
530
531 BLI_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
532 {
533         /* this is a cheap way to set the edge draw, its not precise and will
534          * pick the first 2 faces an edge uses.
535          * The dot comparison is a little arbitrary, but set so that a 5 subd
536          * IcoSphere won't vanish but subd 6 will (as with pre-bmesh blender) */
537
538
539         if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
540              (e->l && (e->l != e->l->radial_next)) &&
541              (dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.9995f))
542         {
543                 med->flag &= ~ME_EDGEDRAW;
544         }
545         else {
546                 med->flag |= ME_EDGEDRAW;
547         }
548 }
549
550 void BM_mesh_bm_to_me(
551         BMesh *bm, Mesh *me,
552         const struct BMeshToMeshParams *params)
553 {
554         MLoop *mloop;
555         MPoly *mpoly;
556         MVert *mvert, *oldverts;
557         MEdge *med, *medge;
558         BMVert *v, *eve;
559         BMEdge *e;
560         BMFace *f;
561         BMIter iter;
562         int i, j, ototvert;
563
564         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
565         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
566         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
567
568         ototvert = me->totvert;
569
570         /* new vertex block */
571         if (bm->totvert == 0) mvert = NULL;
572         else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
573
574         /* new edge block */
575         if (bm->totedge == 0) medge = NULL;
576         else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
577
578         /* new ngon face block */
579         if (bm->totface == 0) mpoly = NULL;
580         else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
581
582         /* new loop block */
583         if (bm->totloop == 0) mloop = NULL;
584         else mloop = MEM_callocN(bm->totloop * sizeof(MLoop), "loadeditbMesh loop");
585
586         /* lets save the old verts just in case we are actually working on
587          * a key ... we now do processing of the keys at the end */
588         oldverts = me->mvert;
589
590         /* don't free this yet */
591         if (oldverts) {
592                 CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
593         }
594
595         /* free custom data */
596         CustomData_free(&me->vdata, me->totvert);
597         CustomData_free(&me->edata, me->totedge);
598         CustomData_free(&me->fdata, me->totface);
599         CustomData_free(&me->ldata, me->totloop);
600         CustomData_free(&me->pdata, me->totpoly);
601
602         /* add new custom data */
603         me->totvert = bm->totvert;
604         me->totedge = bm->totedge;
605         me->totloop = bm->totloop;
606         me->totpoly = bm->totface;
607         /* will be overwritten with a valid value if 'dotess' is set, otherwise we
608          * end up with 'me->totface' and me->mface == NULL which can crash [#28625]
609          */
610         me->totface = 0;
611         me->act_face = -1;
612
613         {
614                 const CustomDataMask mask = CD_MASK_MESH | params->cd_mask_extra;
615                 CustomData_copy(&bm->vdata, &me->vdata, mask, CD_CALLOC, me->totvert);
616                 CustomData_copy(&bm->edata, &me->edata, mask, CD_CALLOC, me->totedge);
617                 CustomData_copy(&bm->ldata, &me->ldata, mask, CD_CALLOC, me->totloop);
618                 CustomData_copy(&bm->pdata, &me->pdata, mask, CD_CALLOC, me->totpoly);
619         }
620
621         CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
622         CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
623         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
624         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
625
626         me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
627
628         /* this is called again, 'dotess' arg is used there */
629         BKE_mesh_update_customdata_pointers(me, 0);
630
631         i = 0;
632         BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
633                 copy_v3_v3(mvert->co, v->co);
634                 normal_float_to_short_v3(mvert->no, v->no);
635
636                 mvert->flag = BM_vert_flag_to_mflag(v);
637
638                 BM_elem_index_set(v, i); /* set_inline */
639
640                 /* copy over customdat */
641                 CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
642
643                 if (cd_vert_bweight_offset != -1) mvert->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(v, cd_vert_bweight_offset);
644
645                 i++;
646                 mvert++;
647
648                 BM_CHECK_ELEMENT(v);
649         }
650         bm->elem_index_dirty &= ~BM_VERT;
651
652         med = medge;
653         i = 0;
654         BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
655                 med->v1 = BM_elem_index_get(e->v1);
656                 med->v2 = BM_elem_index_get(e->v2);
657
658                 med->flag = BM_edge_flag_to_mflag(e);
659
660                 BM_elem_index_set(e, i); /* set_inline */
661
662                 /* copy over customdata */
663                 CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
664
665                 bmesh_quick_edgedraw_flag(med, e);
666
667                 if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_crease_offset);
668                 if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_bweight_offset);
669
670                 i++;
671                 med++;
672                 BM_CHECK_ELEMENT(e);
673         }
674         bm->elem_index_dirty &= ~BM_EDGE;
675
676         i = 0;
677         j = 0;
678         BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
679                 BMLoop *l_iter, *l_first;
680                 mpoly->loopstart = j;
681                 mpoly->totloop = f->len;
682                 mpoly->mat_nr = f->mat_nr;
683                 mpoly->flag = BM_face_flag_to_mflag(f);
684
685                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
686                 do {
687                         mloop->e = BM_elem_index_get(l_iter->e);
688                         mloop->v = BM_elem_index_get(l_iter->v);
689
690                         /* copy over customdata */
691                         CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l_iter->head.data, j);
692
693                         j++;
694                         mloop++;
695                         BM_CHECK_ELEMENT(l_iter);
696                         BM_CHECK_ELEMENT(l_iter->e);
697                         BM_CHECK_ELEMENT(l_iter->v);
698                 } while ((l_iter = l_iter->next) != l_first);
699
700                 if (f == bm->act_face) me->act_face = i;
701
702                 /* copy over customdata */
703                 CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
704
705                 i++;
706                 mpoly++;
707                 BM_CHECK_ELEMENT(f);
708         }
709
710         /* patch hook indices and vertex parents */
711         if (params->calc_object_remap && (ototvert > 0)) {
712                 Object *ob;
713                 ModifierData *md;
714                 BMVert **vertMap = NULL;
715
716                 for (ob = G.main->object.first; ob; ob = ob->id.next) {
717                         if ((ob->parent) && (ob->parent->data == me) && ELEM(ob->partype, PARVERT1, PARVERT3)) {
718
719                                 if (vertMap == NULL) {
720                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
721                                 }
722
723                                 if (ob->par1 < ototvert) {
724                                         eve = vertMap[ob->par1];
725                                         if (eve) ob->par1 = BM_elem_index_get(eve);
726                                 }
727                                 if (ob->par2 < ototvert) {
728                                         eve = vertMap[ob->par2];
729                                         if (eve) ob->par2 = BM_elem_index_get(eve);
730                                 }
731                                 if (ob->par3 < ototvert) {
732                                         eve = vertMap[ob->par3];
733                                         if (eve) ob->par3 = BM_elem_index_get(eve);
734                                 }
735
736                         }
737                         if (ob->data == me) {
738                                 for (md = ob->modifiers.first; md; md = md->next) {
739                                         if (md->type == eModifierType_Hook) {
740                                                 HookModifierData *hmd = (HookModifierData *) md;
741
742                                                 if (vertMap == NULL) {
743                                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
744                                                 }
745
746                                                 for (i = j = 0; i < hmd->totindex; i++) {
747                                                         if (hmd->indexar[i] < ototvert) {
748                                                                 eve = vertMap[hmd->indexar[i]];
749
750                                                                 if (eve) {
751                                                                         hmd->indexar[j++] = BM_elem_index_get(eve);
752                                                                 }
753                                                         }
754                                                         else {
755                                                                 j++;
756                                                         }
757                                                 }
758
759                                                 hmd->totindex = j;
760                                         }
761                                 }
762                         }
763                 }
764
765                 if (vertMap) MEM_freeN(vertMap);
766         }
767
768         BKE_mesh_update_customdata_pointers(me, false);
769
770         {
771                 BMEditSelection *selected;
772                 me->totselect = BLI_listbase_count(&(bm->selected));
773
774                 MEM_SAFE_FREE(me->mselect);
775                 if (me->totselect != 0) {
776                         me->mselect = MEM_mallocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
777                 }
778
779                 for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
780                         if (selected->htype == BM_VERT) {
781                                 me->mselect[i].type = ME_VSEL;
782
783                         }
784                         else if (selected->htype == BM_EDGE) {
785                                 me->mselect[i].type = ME_ESEL;
786
787                         }
788                         else if (selected->htype == BM_FACE) {
789                                 me->mselect[i].type = ME_FSEL;
790                         }
791
792                         me->mselect[i].index = BM_elem_index_get(selected->ele);
793                 }
794         }
795
796         /* see comment below, this logic is in twice */
797
798         if (me->key) {
799                 const int cd_shape_keyindex_offset = CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX);
800
801                 KeyBlock *currkey;
802                 KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
803
804                 float (*ofs)[3] = NULL;
805
806                 /* go through and find any shapekey customdata layers
807                  * that might not have corresponding KeyBlocks, and add them if
808                  * necessary */
809                 j = 0;
810                 for (i = 0; i < bm->vdata.totlayer; i++) {
811                         if (bm->vdata.layers[i].type != CD_SHAPEKEY)
812                                 continue;
813
814                         for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
815                                 if (currkey->uid == bm->vdata.layers[i].uid)
816                                         break;
817                         }
818
819                         if (!currkey) {
820                                 currkey = BKE_keyblock_add(me->key, bm->vdata.layers[i].name);
821                                 currkey->uid = bm->vdata.layers[i].uid;
822                         }
823
824                         j++;
825                 }
826
827
828                 /* editing the base key should update others */
829                 if ((me->key->type == KEY_RELATIVE) && /* only need offsets for relative shape keys */
830                     (actkey != NULL) &&                /* unlikely, but the active key may not be valid if the
831                                                         * bmesh and the mesh are out of sync */
832                     (oldverts != NULL))                /* not used here, but 'oldverts' is used later for applying 'ofs' */
833                 {
834                         const bool act_is_basis = BKE_keyblock_is_basis(me->key, bm->shapenr - 1);
835
836                         /* active key is a base */
837                         if (act_is_basis && (cd_shape_keyindex_offset != -1)) {
838                                 float (*fp)[3] = actkey->data;
839
840                                 ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
841                                 mvert = me->mvert;
842                                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
843                                         const int keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
844
845                                         if (keyi != ORIGINDEX_NONE) {
846                                                 sub_v3_v3v3(ofs[i], mvert->co, fp[keyi]);
847                                         }
848                                         else {
849                                                 /* if there are new vertices in the mesh, we can't propagate the offset
850                                                  * because it will only work for the existing vertices and not the new
851                                                  * ones, creating a mess when doing e.g. subdivide + translate */
852                                                 MEM_freeN(ofs);
853                                                 ofs = NULL;
854                                                 break;
855                                         }
856
857                                         mvert++;
858                                 }
859                         }
860                 }
861
862                 for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
863                         const bool apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
864                         int cd_shape_offset;
865                         int keyi;
866                         float (*ofs_pt)[3] = ofs;
867                         float *newkey, (*oldkey)[3], *fp;
868
869                         j = bm_to_mesh_shape_layer_index_from_kb(bm, currkey);
870                         cd_shape_offset = CustomData_get_n_offset(&bm->vdata, CD_SHAPEKEY, j);
871
872
873                         fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert,  "currkey->data");
874                         oldkey = currkey->data;
875
876                         mvert = me->mvert;
877                         BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
878
879                                 if (currkey == actkey) {
880                                         copy_v3_v3(fp, eve->co);
881
882                                         if (actkey != me->key->refkey) { /* important see bug [#30771] */
883                                                 if (cd_shape_keyindex_offset != -1) {
884                                                         if (oldverts) {
885                                                                 keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
886                                                                 if (keyi != ORIGINDEX_NONE && keyi < currkey->totelem) { /* valid old vertex */
887                                                                         copy_v3_v3(mvert->co, oldverts[keyi].co);
888                                                                 }
889                                                         }
890                                                 }
891                                         }
892                                 }
893                                 else if (j != -1) {
894                                         /* in most cases this runs */
895                                         copy_v3_v3(fp, BM_ELEM_CD_GET_VOID_P(eve, cd_shape_offset));
896                                 }
897                                 else if ((oldkey != NULL) &&
898                                          (cd_shape_keyindex_offset != -1) &&
899                                          ((keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset)) != ORIGINDEX_NONE) &&
900                                          (keyi < currkey->totelem))
901                                 {
902                                         /* old method of reconstructing keys via vertice's original key indices,
903                                          * currently used if the new method above fails (which is theoretically
904                                          * possible in certain cases of undo) */
905                                         copy_v3_v3(fp, oldkey[keyi]);
906                                 }
907                                 else {
908                                         /* fail! fill in with dummy value */
909                                         copy_v3_v3(fp, mvert->co);
910                                 }
911
912                                 /* propagate edited basis offsets to other shapes */
913                                 if (apply_offset) {
914                                         add_v3_v3(fp, *ofs_pt++);
915                                         /* Apply back new coordinates of offsetted shapekeys into BMesh.
916                                          * Otherwise, in case we call again BM_mesh_bm_to_me on same BMesh, we'll apply diff from previous
917                                          * call to BM_mesh_bm_to_me, to shapekey values from *original creation of the BMesh*. See T50524. */
918                                         copy_v3_v3(BM_ELEM_CD_GET_VOID_P(eve, cd_shape_offset), fp);
919                                 }
920
921                                 fp += 3;
922                                 mvert++;
923                         }
924
925                         currkey->totelem = bm->totvert;
926                         if (currkey->data) {
927                                 MEM_freeN(currkey->data);
928                         }
929                         currkey->data = newkey;
930                 }
931
932                 if (ofs) MEM_freeN(ofs);
933         }
934
935         if (oldverts) MEM_freeN(oldverts);
936
937         /* topology could be changed, ensure mdisps are ok */
938         multires_topology_changed(me);
939 }