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