Merge remote-tracking branch 'origin/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_mesh_runtime.h"
92 #include "BKE_customdata.h"
93 #include "BKE_multires.h"
94
95 #include "BKE_global.h" /* ugh - for looping over all objects */
96 #include "BKE_main.h"
97 #include "BKE_key.h"
98
99 #include "bmesh.h"
100 #include "intern/bmesh_private.h" /* for element checking */
101
102 void BM_mesh_cd_flag_ensure(BMesh *bm, Mesh *mesh, const char cd_flag)
103 {
104         const char cd_flag_all = BM_mesh_cd_flag_from_bmesh(bm) | cd_flag;
105         BM_mesh_cd_flag_apply(bm, cd_flag_all);
106         if (mesh) {
107                 mesh->cd_flag = cd_flag_all;
108         }
109 }
110
111 void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag)
112 {
113         /* CustomData_bmesh_init_pool() must run first */
114         BLI_assert(bm->vdata.totlayer == 0 || bm->vdata.pool != NULL);
115         BLI_assert(bm->edata.totlayer == 0 || bm->edata.pool != NULL);
116         BLI_assert(bm->pdata.totlayer == 0 || bm->pdata.pool != NULL);
117
118         if (cd_flag & ME_CDFLAG_VERT_BWEIGHT) {
119                 if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
120                         BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);
121                 }
122         }
123         else {
124                 if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
125                         BM_data_layer_free(bm, &bm->vdata, CD_BWEIGHT);
126                 }
127         }
128
129         if (cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {
130                 if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
131                         BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);
132                 }
133         }
134         else {
135                 if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
136                         BM_data_layer_free(bm, &bm->edata, CD_BWEIGHT);
137                 }
138         }
139
140         if (cd_flag & ME_CDFLAG_EDGE_CREASE) {
141                 if (!CustomData_has_layer(&bm->edata, CD_CREASE)) {
142                         BM_data_layer_add(bm, &bm->edata, CD_CREASE);
143                 }
144         }
145         else {
146                 if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
147                         BM_data_layer_free(bm, &bm->edata, CD_CREASE);
148                 }
149         }
150 }
151
152 char BM_mesh_cd_flag_from_bmesh(BMesh *bm)
153 {
154         char cd_flag = 0;
155         if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
156                 cd_flag |= ME_CDFLAG_VERT_BWEIGHT;
157         }
158         if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
159                 cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
160         }
161         if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
162                 cd_flag |= ME_CDFLAG_EDGE_CREASE;
163         }
164         return cd_flag;
165 }
166
167 /* Static function for alloc (duplicate in modifiers_bmesh.c) */
168 static BMFace *bm_face_create_from_mpoly(
169         MPoly *mp, MLoop *ml,
170         BMesh *bm, BMVert **vtable, BMEdge **etable)
171 {
172         BMVert **verts = BLI_array_alloca(verts, mp->totloop);
173         BMEdge **edges = BLI_array_alloca(edges, mp->totloop);
174         int j;
175
176         for (j = 0; j < mp->totloop; j++, ml++) {
177                 verts[j] = vtable[ml->v];
178                 edges[j] = etable[ml->e];
179         }
180
181         return BM_face_create(bm, verts, edges, mp->totloop, NULL, BM_CREATE_SKIP_CD);
182 }
183
184
185 /**
186  * \brief Mesh -> BMesh
187  * \param bm: The mesh to write into, while this is typically a newly created BMesh,
188  * merging into existing data is supported.
189  * Note the custom-data layout isn't used.
190  * If more comprehensive merging is needed we should move this into a separate function
191  * since this should be kept fast for edit-mode switching and storing undo steps.
192  *
193  * \warning This function doesn't calculate face normals.
194  */
195 void BM_mesh_bm_from_me(
196         BMesh *bm, Mesh *me,
197         const struct BMeshFromMeshParams *params)
198 {
199         const bool is_new =
200                 !(bm->totvert ||
201                   (bm->vdata.totlayer || bm->edata.totlayer || bm->pdata.totlayer || bm->ldata.totlayer));
202         MVert *mvert;
203         MEdge *medge;
204         MLoop *mloop;
205         MPoly *mp;
206         KeyBlock *actkey, *block;
207         BMVert *v, **vtable = NULL;
208         BMEdge *e, **etable = NULL;
209         BMFace *f, **ftable = NULL;
210         float (*keyco)[3] = NULL;
211         int totloops, i;
212         const int64_t mask = CD_MASK_BMESH | params->cd_mask_extra;
213         const int64_t mask_loop_only = mask & ~CD_MASK_ORIGINDEX;
214
215         if (!me || !me->totvert) {
216                 if (me && is_new) { /*no verts? still copy customdata layout*/
217                         CustomData_copy(&me->vdata, &bm->vdata, mask, CD_ASSIGN, 0);
218                         CustomData_copy(&me->edata, &bm->edata, mask, CD_ASSIGN, 0);
219                         CustomData_copy(&me->ldata, &bm->ldata, mask_loop_only, CD_ASSIGN, 0);
220                         CustomData_copy(&me->pdata, &bm->pdata, mask, CD_ASSIGN, 0);
221
222                         CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
223                         CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
224                         CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
225                         CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
226                 }
227                 return; /* sanity check */
228         }
229
230         if (is_new) {
231                 CustomData_copy(&me->vdata, &bm->vdata, mask, CD_CALLOC, 0);
232                 CustomData_copy(&me->edata, &bm->edata, mask, CD_CALLOC, 0);
233                 CustomData_copy(&me->ldata, &bm->ldata, mask_loop_only, CD_CALLOC, 0);
234                 CustomData_copy(&me->pdata, &bm->pdata, mask, CD_CALLOC, 0);
235         }
236
237         /* -------------------------------------------------------------------- */
238         /* Shape Key */
239         int tot_shape_keys = me->key ? BLI_listbase_count(&me->key->block) : 0;
240         if (is_new == false) {
241                 tot_shape_keys = min_ii(tot_shape_keys, CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY));
242         }
243         const float (**shape_key_table)[3] = tot_shape_keys ? BLI_array_alloca(shape_key_table, tot_shape_keys) : NULL;
244
245         if ((params->active_shapekey != 0) && (me->key != NULL)) {
246                 actkey = BLI_findlink(&me->key->block, params->active_shapekey - 1);
247         }
248         else {
249                 actkey = NULL;
250         }
251
252         if (is_new) {
253                 if (tot_shape_keys || params->add_key_index) {
254                         CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
255                 }
256         }
257
258         if (tot_shape_keys) {
259                 if (is_new) {
260                         /* check if we need to generate unique ids for the shapekeys.
261                          * this also exists in the file reading code, but is here for
262                          * a sanity check */
263                         if (!me->key->uidgen) {
264                                 fprintf(stderr,
265                                         "%s had to generate shape key uid's in a situation we shouldn't need to! "
266                                         "(bmesh internal error)\n",
267                                         __func__);
268
269                                 me->key->uidgen = 1;
270                                 for (block = me->key->block.first; block; block = block->next) {
271                                         block->uid = me->key->uidgen++;
272                                 }
273                         }
274                 }
275
276                 if (actkey && actkey->totelem == me->totvert) {
277                         keyco = params->use_shapekey ? actkey->data : NULL;
278                         if (is_new) {
279                                 bm->shapenr = params->active_shapekey;
280                         }
281                 }
282
283                 for (i = 0, block = me->key->block.first; i < tot_shape_keys; block = block->next, i++) {
284                         if (is_new) {
285                                 CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
286                                                            CD_ASSIGN, NULL, 0, block->name);
287                                 int j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
288                                 bm->vdata.layers[j].uid = block->uid;
289                         }
290                         shape_key_table[i] = (const float (*)[3])block->data;
291                 }
292         }
293
294         if (is_new) {
295                 CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
296                 CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
297                 CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
298                 CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
299
300                 BM_mesh_cd_flag_apply(bm, me->cd_flag);
301         }
302
303         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
304         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
305         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
306         const int cd_shape_key_offset = me->key ? CustomData_get_offset(&bm->vdata, CD_SHAPEKEY) : -1;
307         const int cd_shape_keyindex_offset = is_new && (tot_shape_keys || params->add_key_index) ?
308                   CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX) : -1;
309
310         vtable = MEM_mallocN(sizeof(BMVert **) * me->totvert, __func__);
311
312         for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
313                 v = vtable[i] = BM_vert_create(bm, keyco ? keyco[i] : mvert->co, NULL, BM_CREATE_SKIP_CD);
314                 BM_elem_index_set(v, i); /* set_ok */
315
316                 /* transfer flag */
317                 v->head.hflag = BM_vert_flag_from_mflag(mvert->flag & ~SELECT);
318
319                 /* this is necessary for selection counts to work properly */
320                 if (mvert->flag & SELECT) {
321                         BM_vert_select_set(bm, v, true);
322                 }
323
324                 normal_short_to_float_v3(v->no, mvert->no);
325
326                 /* Copy Custom Data */
327                 CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data, true);
328
329                 if (cd_vert_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(v, cd_vert_bweight_offset, (float)mvert->bweight / 255.0f);
330
331                 /* set shape key original index */
332                 if (cd_shape_keyindex_offset != -1) BM_ELEM_CD_SET_INT(v, cd_shape_keyindex_offset, i);
333
334                 /* set shapekey data */
335                 if (tot_shape_keys) {
336                         float (*co_dst)[3] = BM_ELEM_CD_GET_VOID_P(v, cd_shape_key_offset);
337                         for (int j = 0; j < tot_shape_keys; j++, co_dst++) {
338                                 copy_v3_v3(*co_dst, shape_key_table[j][i]);
339                         }
340                 }
341         }
342         if (is_new) {
343                 bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
344         }
345
346         etable = MEM_mallocN(sizeof(BMEdge **) * me->totedge, __func__);
347
348         medge = me->medge;
349         for (i = 0; i < me->totedge; i++, medge++) {
350                 e = etable[i] = BM_edge_create(bm, vtable[medge->v1], vtable[medge->v2], NULL, BM_CREATE_SKIP_CD);
351                 BM_elem_index_set(e, i); /* set_ok */
352
353                 /* transfer flags */
354                 e->head.hflag = BM_edge_flag_from_mflag(medge->flag & ~SELECT);
355
356                 /* this is necessary for selection counts to work properly */
357                 if (medge->flag & SELECT) {
358                         BM_edge_select_set(bm, e, true);
359                 }
360
361                 /* Copy Custom Data */
362                 CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data, true);
363
364                 if (cd_edge_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_bweight_offset, (float)medge->bweight / 255.0f);
365                 if (cd_edge_crease_offset  != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_crease_offset,  (float)medge->crease  / 255.0f);
366
367         }
368         if (is_new) {
369                 bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
370         }
371
372         /* only needed for selection. */
373         if (me->mselect && me->totselect != 0) {
374                 ftable = MEM_mallocN(sizeof(BMFace **) * me->totpoly, __func__);
375         }
376
377         mloop = me->mloop;
378         mp = me->mpoly;
379         for (i = 0, totloops = 0; i < me->totpoly; i++, mp++) {
380                 BMLoop *l_iter;
381                 BMLoop *l_first;
382
383                 f = bm_face_create_from_mpoly(mp, mloop + mp->loopstart,
384                                               bm, vtable, etable);
385                 if (ftable != NULL) {
386                         ftable[i] = f;
387                 }
388
389                 if (UNLIKELY(f == NULL)) {
390                         printf("%s: Warning! Bad face in mesh"
391                                " \"%s\" at index %d!, skipping\n",
392                                __func__, me->id.name + 2, i);
393                         continue;
394                 }
395
396                 /* don't use 'i' since we may have skipped the face */
397                 BM_elem_index_set(f, bm->totface - 1); /* set_ok */
398
399                 /* transfer flag */
400                 f->head.hflag = BM_face_flag_from_mflag(mp->flag & ~ME_FACE_SEL);
401
402                 /* this is necessary for selection counts to work properly */
403                 if (mp->flag & ME_FACE_SEL) {
404                         BM_face_select_set(bm, f, true);
405                 }
406
407                 f->mat_nr = mp->mat_nr;
408                 if (i == me->act_face) bm->act_face = f;
409
410                 int j = mp->loopstart;
411                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
412                 do {
413                         /* don't use 'j' since we may have skipped some faces, hence some loops. */
414                         BM_elem_index_set(l_iter, totloops++); /* set_ok */
415
416                         /* Save index of correspsonding MLoop */
417                         CustomData_to_bmesh_block(&me->ldata, &bm->ldata, j++, &l_iter->head.data, true);
418                 } while ((l_iter = l_iter->next) != l_first);
419
420                 /* Copy Custom Data */
421                 CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data, true);
422
423                 if (params->calc_face_normal) {
424                         BM_face_normal_update(f);
425                 }
426         }
427         if (is_new) {
428                 bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP); /* added in order, clear dirty flag */
429         }
430
431         /* -------------------------------------------------------------------- */
432         /* MSelect clears the array elements (avoid adding multiple times).
433          *
434          * Take care to keep this last and not use (v/e/ftable) after this.
435          */
436
437         if (me->mselect && me->totselect != 0) {
438                 MSelect *msel;
439                 for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
440                         BMElem **ele_p;
441                         switch (msel->type) {
442                                 case ME_VSEL:
443                                         ele_p = (BMElem **)&vtable[msel->index];
444                                         break;
445                                 case ME_ESEL:
446                                         ele_p = (BMElem **)&etable[msel->index];
447                                         break;
448                                 case ME_FSEL:
449                                         ele_p = (BMElem **)&ftable[msel->index];
450                                         break;
451                                 default:
452                                         continue;
453                         }
454
455                         if (*ele_p != NULL) {
456                                 BM_select_history_store_notest(bm, *ele_p);
457                                 *ele_p = NULL;
458                         }
459                 }
460         }
461         else {
462                 BM_select_history_clear(bm);
463         }
464
465         MEM_freeN(vtable);
466         MEM_freeN(etable);
467         if (ftable) {
468                 MEM_freeN(ftable);
469         }
470 }
471
472
473 /**
474  * \brief BMesh -> Mesh
475  */
476 static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
477 {
478         const int cd_shape_keyindex_offset = CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX);
479         BMVert **vertMap = NULL;
480         BMVert *eve;
481         int i = 0;
482         BMIter iter;
483
484         /* caller needs to ensure this */
485         BLI_assert(ototvert > 0);
486
487         vertMap = MEM_callocN(sizeof(*vertMap) * ototvert, "vertMap");
488         if (cd_shape_keyindex_offset != -1) {
489                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
490                         const int keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
491                         if ((keyi != ORIGINDEX_NONE) &&
492                             (keyi < ototvert) &&
493                             /* not fool-proof, but chances are if we have many verts with the same index,
494                              * we will want to use the first one, since the second is more likely to be a duplicate. */
495                             (vertMap[keyi] == NULL))
496                         {
497                                 vertMap[keyi] = eve;
498                         }
499                 }
500         }
501         else {
502                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
503                         if (i < ototvert) {
504                                 vertMap[i] = eve;
505                         }
506                         else {
507                                 break;
508                         }
509                 }
510         }
511
512         return vertMap;
513 }
514
515 /**
516  * returns customdata shapekey index from a keyblock or -1
517  * \note could split this out into a more generic function */
518 static int bm_to_mesh_shape_layer_index_from_kb(BMesh *bm, KeyBlock *currkey)
519 {
520         int i;
521         int j = 0;
522
523         for (i = 0; i < bm->vdata.totlayer; i++) {
524                 if (bm->vdata.layers[i].type == CD_SHAPEKEY) {
525                         if (currkey->uid == bm->vdata.layers[i].uid) {
526                                 return j;
527                         }
528                         j++;
529                 }
530         }
531         return -1;
532 }
533
534 BLI_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
535 {
536         /* this is a cheap way to set the edge draw, its not precise and will
537          * pick the first 2 faces an edge uses.
538          * The dot comparison is a little arbitrary, but set so that a 5 subd
539          * IcoSphere won't vanish but subd 6 will (as with pre-bmesh blender) */
540
541
542         if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
543              (e->l && (e->l != e->l->radial_next)) &&
544              (dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.9995f))
545         {
546                 med->flag &= ~ME_EDGEDRAW;
547         }
548         else {
549                 med->flag |= ME_EDGEDRAW;
550         }
551 }
552
553 /**
554  *
555  * \param bmain May be NULL in case \a calc_object_remap parameter option is not set.
556  */
557 void BM_mesh_bm_to_me(
558         Main *bmain, BMesh *bm, Mesh *me,
559         const struct BMeshToMeshParams *params)
560 {
561         MLoop *mloop;
562         MPoly *mpoly;
563         MVert *mvert, *oldverts;
564         MEdge *med, *medge;
565         BMVert *v, *eve;
566         BMEdge *e;
567         BMFace *f;
568         BMIter iter;
569         int i, j, ototvert;
570
571         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
572         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
573         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
574
575         ototvert = me->totvert;
576
577         /* new vertex block */
578         if (bm->totvert == 0) mvert = NULL;
579         else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
580
581         /* new edge block */
582         if (bm->totedge == 0) medge = NULL;
583         else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
584
585         /* new ngon face block */
586         if (bm->totface == 0) mpoly = NULL;
587         else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
588
589         /* new loop block */
590         if (bm->totloop == 0) mloop = NULL;
591         else mloop = MEM_callocN(bm->totloop * sizeof(MLoop), "loadeditbMesh loop");
592
593         /* lets save the old verts just in case we are actually working on
594          * a key ... we now do processing of the keys at the end */
595         oldverts = me->mvert;
596
597         /* don't free this yet */
598         if (oldverts) {
599                 CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
600         }
601
602         /* free custom data */
603         CustomData_free(&me->vdata, me->totvert);
604         CustomData_free(&me->edata, me->totedge);
605         CustomData_free(&me->fdata, me->totface);
606         CustomData_free(&me->ldata, me->totloop);
607         CustomData_free(&me->pdata, me->totpoly);
608
609         /* add new custom data */
610         me->totvert = bm->totvert;
611         me->totedge = bm->totedge;
612         me->totloop = bm->totloop;
613         me->totpoly = bm->totface;
614         /* will be overwritten with a valid value if 'dotess' is set, otherwise we
615          * end up with 'me->totface' and me->mface == NULL which can crash [#28625]
616          */
617         me->totface = 0;
618         me->act_face = -1;
619
620         {
621                 const CustomDataMask mask = CD_MASK_MESH | params->cd_mask_extra;
622                 CustomData_copy(&bm->vdata, &me->vdata, mask, CD_CALLOC, me->totvert);
623                 CustomData_copy(&bm->edata, &me->edata, mask, CD_CALLOC, me->totedge);
624                 CustomData_copy(&bm->ldata, &me->ldata, mask, CD_CALLOC, me->totloop);
625                 CustomData_copy(&bm->pdata, &me->pdata, mask, CD_CALLOC, me->totpoly);
626         }
627
628         CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
629         CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
630         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
631         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
632
633         me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
634
635         /* this is called again, 'dotess' arg is used there */
636         BKE_mesh_update_customdata_pointers(me, 0);
637
638         i = 0;
639         BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
640                 copy_v3_v3(mvert->co, v->co);
641                 normal_float_to_short_v3(mvert->no, v->no);
642
643                 mvert->flag = BM_vert_flag_to_mflag(v);
644
645                 BM_elem_index_set(v, i); /* set_inline */
646
647                 /* copy over customdat */
648                 CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
649
650                 if (cd_vert_bweight_offset != -1) mvert->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(v, cd_vert_bweight_offset);
651
652                 i++;
653                 mvert++;
654
655                 BM_CHECK_ELEMENT(v);
656         }
657         bm->elem_index_dirty &= ~BM_VERT;
658
659         med = medge;
660         i = 0;
661         BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
662                 med->v1 = BM_elem_index_get(e->v1);
663                 med->v2 = BM_elem_index_get(e->v2);
664
665                 med->flag = BM_edge_flag_to_mflag(e);
666
667                 BM_elem_index_set(e, i); /* set_inline */
668
669                 /* copy over customdata */
670                 CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
671
672                 bmesh_quick_edgedraw_flag(med, e);
673
674                 if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_crease_offset);
675                 if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_bweight_offset);
676
677                 i++;
678                 med++;
679                 BM_CHECK_ELEMENT(e);
680         }
681         bm->elem_index_dirty &= ~BM_EDGE;
682
683         i = 0;
684         j = 0;
685         BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
686                 BMLoop *l_iter, *l_first;
687                 mpoly->loopstart = j;
688                 mpoly->totloop = f->len;
689                 mpoly->mat_nr = f->mat_nr;
690                 mpoly->flag = BM_face_flag_to_mflag(f);
691
692                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
693                 do {
694                         mloop->e = BM_elem_index_get(l_iter->e);
695                         mloop->v = BM_elem_index_get(l_iter->v);
696
697                         /* copy over customdata */
698                         CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l_iter->head.data, j);
699
700                         j++;
701                         mloop++;
702                         BM_CHECK_ELEMENT(l_iter);
703                         BM_CHECK_ELEMENT(l_iter->e);
704                         BM_CHECK_ELEMENT(l_iter->v);
705                 } while ((l_iter = l_iter->next) != l_first);
706
707                 if (f == bm->act_face) me->act_face = i;
708
709                 /* copy over customdata */
710                 CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
711
712                 i++;
713                 mpoly++;
714                 BM_CHECK_ELEMENT(f);
715         }
716
717         /* patch hook indices and vertex parents */
718         if (params->calc_object_remap && (ototvert > 0)) {
719                 BLI_assert(bmain != NULL);
720                 Object *ob;
721                 ModifierData *md;
722                 BMVert **vertMap = NULL;
723
724                 for (ob = bmain->object.first; ob; ob = ob->id.next) {
725                         if ((ob->parent) && (ob->parent->data == me) && ELEM(ob->partype, PARVERT1, PARVERT3)) {
726
727                                 if (vertMap == NULL) {
728                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
729                                 }
730
731                                 if (ob->par1 < ototvert) {
732                                         eve = vertMap[ob->par1];
733                                         if (eve) ob->par1 = BM_elem_index_get(eve);
734                                 }
735                                 if (ob->par2 < ototvert) {
736                                         eve = vertMap[ob->par2];
737                                         if (eve) ob->par2 = BM_elem_index_get(eve);
738                                 }
739                                 if (ob->par3 < ototvert) {
740                                         eve = vertMap[ob->par3];
741                                         if (eve) ob->par3 = BM_elem_index_get(eve);
742                                 }
743
744                         }
745                         if (ob->data == me) {
746                                 for (md = ob->modifiers.first; md; md = md->next) {
747                                         if (md->type == eModifierType_Hook) {
748                                                 HookModifierData *hmd = (HookModifierData *) md;
749
750                                                 if (vertMap == NULL) {
751                                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
752                                                 }
753
754                                                 for (i = j = 0; i < hmd->totindex; i++) {
755                                                         if (hmd->indexar[i] < ototvert) {
756                                                                 eve = vertMap[hmd->indexar[i]];
757
758                                                                 if (eve) {
759                                                                         hmd->indexar[j++] = BM_elem_index_get(eve);
760                                                                 }
761                                                         }
762                                                         else {
763                                                                 j++;
764                                                         }
765                                                 }
766
767                                                 hmd->totindex = j;
768                                         }
769                                 }
770                         }
771                 }
772
773                 if (vertMap) MEM_freeN(vertMap);
774         }
775
776         BKE_mesh_update_customdata_pointers(me, false);
777
778         {
779                 BMEditSelection *selected;
780                 me->totselect = BLI_listbase_count(&(bm->selected));
781
782                 MEM_SAFE_FREE(me->mselect);
783                 if (me->totselect != 0) {
784                         me->mselect = MEM_mallocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
785                 }
786
787                 for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
788                         if (selected->htype == BM_VERT) {
789                                 me->mselect[i].type = ME_VSEL;
790
791                         }
792                         else if (selected->htype == BM_EDGE) {
793                                 me->mselect[i].type = ME_ESEL;
794
795                         }
796                         else if (selected->htype == BM_FACE) {
797                                 me->mselect[i].type = ME_FSEL;
798                         }
799
800                         me->mselect[i].index = BM_elem_index_get(selected->ele);
801                 }
802         }
803
804         /* see comment below, this logic is in twice */
805
806         if (me->key) {
807                 const int cd_shape_keyindex_offset = CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX);
808
809                 KeyBlock *currkey;
810                 KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
811
812                 float (*ofs)[3] = NULL;
813
814                 /* go through and find any shapekey customdata layers
815                  * that might not have corresponding KeyBlocks, and add them if
816                  * necessary */
817                 j = 0;
818                 for (i = 0; i < bm->vdata.totlayer; i++) {
819                         if (bm->vdata.layers[i].type != CD_SHAPEKEY)
820                                 continue;
821
822                         for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
823                                 if (currkey->uid == bm->vdata.layers[i].uid)
824                                         break;
825                         }
826
827                         if (!currkey) {
828                                 currkey = BKE_keyblock_add(me->key, bm->vdata.layers[i].name);
829                                 currkey->uid = bm->vdata.layers[i].uid;
830                         }
831
832                         j++;
833                 }
834
835
836                 /* editing the base key should update others */
837                 if ((me->key->type == KEY_RELATIVE) && /* only need offsets for relative shape keys */
838                     (actkey != NULL) &&                /* unlikely, but the active key may not be valid if the
839                                                         * bmesh and the mesh are out of sync */
840                     (oldverts != NULL))                /* not used here, but 'oldverts' is used later for applying 'ofs' */
841                 {
842                         const bool act_is_basis = BKE_keyblock_is_basis(me->key, bm->shapenr - 1);
843
844                         /* active key is a base */
845                         if (act_is_basis && (cd_shape_keyindex_offset != -1)) {
846                                 float (*fp)[3] = actkey->data;
847
848                                 ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
849                                 mvert = me->mvert;
850                                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
851                                         const int keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
852
853                                         if (keyi != ORIGINDEX_NONE) {
854                                                 sub_v3_v3v3(ofs[i], mvert->co, fp[keyi]);
855                                         }
856                                         else {
857                                                 /* if there are new vertices in the mesh, we can't propagate the offset
858                                                  * because it will only work for the existing vertices and not the new
859                                                  * ones, creating a mess when doing e.g. subdivide + translate */
860                                                 MEM_freeN(ofs);
861                                                 ofs = NULL;
862                                                 break;
863                                         }
864
865                                         mvert++;
866                                 }
867                         }
868                 }
869
870                 for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
871                         const bool apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
872                         int cd_shape_offset;
873                         int keyi;
874                         float (*ofs_pt)[3] = ofs;
875                         float *newkey, (*oldkey)[3], *fp;
876
877                         j = bm_to_mesh_shape_layer_index_from_kb(bm, currkey);
878                         cd_shape_offset = CustomData_get_n_offset(&bm->vdata, CD_SHAPEKEY, j);
879
880
881                         fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert,  "currkey->data");
882                         oldkey = currkey->data;
883
884                         mvert = me->mvert;
885                         BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
886
887                                 if (currkey == actkey) {
888                                         copy_v3_v3(fp, eve->co);
889
890                                         if (actkey != me->key->refkey) { /* important see bug [#30771] */
891                                                 if (cd_shape_keyindex_offset != -1) {
892                                                         if (oldverts) {
893                                                                 keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset);
894                                                                 if (keyi != ORIGINDEX_NONE && keyi < currkey->totelem) { /* valid old vertex */
895                                                                         copy_v3_v3(mvert->co, oldverts[keyi].co);
896                                                                 }
897                                                         }
898                                                 }
899                                         }
900                                 }
901                                 else if (j != -1) {
902                                         /* in most cases this runs */
903                                         copy_v3_v3(fp, BM_ELEM_CD_GET_VOID_P(eve, cd_shape_offset));
904                                 }
905                                 else if ((oldkey != NULL) &&
906                                          (cd_shape_keyindex_offset != -1) &&
907                                          ((keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset)) != ORIGINDEX_NONE) &&
908                                          (keyi < currkey->totelem))
909                                 {
910                                         /* old method of reconstructing keys via vertice's original key indices,
911                                          * currently used if the new method above fails (which is theoretically
912                                          * possible in certain cases of undo) */
913                                         copy_v3_v3(fp, oldkey[keyi]);
914                                 }
915                                 else {
916                                         /* fail! fill in with dummy value */
917                                         copy_v3_v3(fp, mvert->co);
918                                 }
919
920                                 /* propagate edited basis offsets to other shapes */
921                                 if (apply_offset) {
922                                         add_v3_v3(fp, *ofs_pt++);
923                                         /* Apply back new coordinates of offsetted shapekeys into BMesh.
924                                          * Otherwise, in case we call again BM_mesh_bm_to_me on same BMesh, we'll apply diff from previous
925                                          * call to BM_mesh_bm_to_me, to shapekey values from *original creation of the BMesh*. See T50524. */
926                                         copy_v3_v3(BM_ELEM_CD_GET_VOID_P(eve, cd_shape_offset), fp);
927                                 }
928
929                                 fp += 3;
930                                 mvert++;
931                         }
932
933                         currkey->totelem = bm->totvert;
934                         if (currkey->data) {
935                                 MEM_freeN(currkey->data);
936                         }
937                         currkey->data = newkey;
938                 }
939
940                 if (ofs) MEM_freeN(ofs);
941         }
942
943         if (oldverts) MEM_freeN(oldverts);
944
945         /* topology could be changed, ensure mdisps are ok */
946         multires_topology_changed(me);
947
948         /* to be removed as soon as COW is enabled by default. */
949         BKE_mesh_runtime_clear_geometry(me);
950 }
951
952 /**
953  * A version of #BM_mesh_bm_to_me intended for getting the mesh to pass to the modifier stack for evaluation,
954  * instad of mode switching (where we make sure all data is kept and do expensive lookups to maintain shape keys).
955  *
956  * Key differences:
957  *
958  * - Don't support merging with existing mesh.
959  * - Ignore shape-keys.
960  * - Ignore vertex-parents.
961  * - Ignore selection history.
962  * - Uses simpler method to calculate #ME_EDGEDRAW
963  * - Uses #CD_MASK_DERIVEDMESH instead of #CD_MASK_MESH.
964  *
965  * \note Was `cddm_from_bmesh_ex` in 2.7x, removed `MFace` support.
966  */
967 void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const int64_t cd_mask_extra)
968 {
969         /* must be an empty mesh. */
970         BLI_assert(me->totvert == 0);
971         BLI_assert((cd_mask_extra & CD_MASK_SHAPEKEY) == 0);
972
973         me->totvert = bm->totvert;
974         me->totedge = bm->totedge;
975         me->totface = 0;
976         me->totloop = bm->totloop;
977         me->totpoly = bm->totface;
978
979         CustomData_add_layer(&me->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, bm->totvert);
980         CustomData_add_layer(&me->edata, CD_ORIGINDEX, CD_CALLOC, NULL, bm->totedge);
981         CustomData_add_layer(&me->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, bm->totface);
982
983         CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, bm->totvert);
984         CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, bm->totedge);
985         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_CALLOC, NULL, bm->totloop);
986         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_CALLOC, NULL, bm->totface);
987
988         /* don't process shapekeys, we only feed them through the modifier stack as needed,
989          * e.g. for applying modifiers or the like*/
990         const CustomDataMask mask = (CD_MASK_DERIVEDMESH | cd_mask_extra) & ~CD_MASK_SHAPEKEY;
991         CustomData_merge(&bm->vdata, &me->vdata, mask, CD_CALLOC, me->totvert);
992         CustomData_merge(&bm->edata, &me->edata, mask, CD_CALLOC, me->totedge);
993         CustomData_merge(&bm->ldata, &me->ldata, mask, CD_CALLOC, me->totloop);
994         CustomData_merge(&bm->pdata, &me->pdata, mask, CD_CALLOC, me->totpoly);
995
996         BKE_mesh_update_customdata_pointers(me, false);
997
998         BMIter iter;
999         BMVert *eve;
1000         BMEdge *eed;
1001         BMFace *efa;
1002         MVert *mvert = me->mvert;
1003         MEdge *medge = me->medge;
1004         MLoop *mloop = me->mloop;
1005         MPoly *mpoly = me->mpoly;
1006         int *index, add_orig;
1007         unsigned int i, j;
1008
1009         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
1010         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
1011         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
1012
1013         me->runtime.deformed_only = true;
1014
1015         /* don't add origindex layer if one already exists */
1016         add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
1017
1018         index = CustomData_get_layer(&me->vdata, CD_ORIGINDEX);
1019
1020         BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
1021                 MVert *mv = &mvert[i];
1022
1023                 copy_v3_v3(mv->co, eve->co);
1024
1025                 BM_elem_index_set(eve, i); /* set_inline */
1026
1027                 normal_float_to_short_v3(mv->no, eve->no);
1028
1029                 mv->flag = BM_vert_flag_to_mflag(eve);
1030
1031                 if (cd_vert_bweight_offset != -1) mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
1032
1033                 if (add_orig) *index++ = i;
1034
1035                 CustomData_from_bmesh_block(&bm->vdata, &me->vdata, eve->head.data, i);
1036         }
1037         bm->elem_index_dirty &= ~BM_VERT;
1038
1039         index = CustomData_get_layer(&me->edata, CD_ORIGINDEX);
1040         BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
1041                 MEdge *med = &medge[i];
1042
1043                 BM_elem_index_set(eed, i); /* set_inline */
1044
1045                 med->v1 = BM_elem_index_get(eed->v1);
1046                 med->v2 = BM_elem_index_get(eed->v2);
1047
1048                 med->flag = BM_edge_flag_to_mflag(eed);
1049
1050                 /* handle this differently to editmode switching,
1051                  * only enable draw for single user edges rather then calculating angle */
1052                 if ((med->flag & ME_EDGEDRAW) == 0) {
1053                         if (eed->l && eed->l == eed->l->radial_next) {
1054                                 med->flag |= ME_EDGEDRAW;
1055                         }
1056                 }
1057
1058                 if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
1059                 if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
1060
1061                 CustomData_from_bmesh_block(&bm->edata, &me->edata, eed->head.data, i);
1062                 if (add_orig) *index++ = i;
1063         }
1064         bm->elem_index_dirty &= ~BM_EDGE;
1065
1066         index = CustomData_get_layer(&me->pdata, CD_ORIGINDEX);
1067         j = 0;
1068         BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
1069                 BMLoop *l_iter;
1070                 BMLoop *l_first;
1071                 MPoly *mp = &mpoly[i];
1072
1073                 BM_elem_index_set(efa, i); /* set_inline */
1074
1075                 mp->totloop = efa->len;
1076                 mp->flag = BM_face_flag_to_mflag(efa);
1077                 mp->loopstart = j;
1078                 mp->mat_nr = efa->mat_nr;
1079
1080                 l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
1081                 do {
1082                         mloop->v = BM_elem_index_get(l_iter->v);
1083                         mloop->e = BM_elem_index_get(l_iter->e);
1084                         CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l_iter->head.data, j);
1085
1086                         BM_elem_index_set(l_iter, j); /* set_inline */
1087
1088                         j++;
1089                         mloop++;
1090                 } while ((l_iter = l_iter->next) != l_first);
1091
1092                 CustomData_from_bmesh_block(&bm->pdata, &me->pdata, efa->head.data, i);
1093
1094                 if (add_orig) *index++ = i;
1095         }
1096         bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
1097
1098         me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
1099 }