a8c27e0a7616054af647fa31018ff6adab473d83
[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_array.h"
88 #include "BLI_math_vector.h"
89
90 #include "BKE_mesh.h"
91 #include "BKE_customdata.h"
92 #include "BKE_multires.h"
93
94 #include "BKE_global.h" /* ugh - for looping over all objects */
95 #include "BKE_main.h"
96 #include "BKE_key.h"
97
98 #include "bmesh.h"
99 #include "intern/bmesh_private.h" /* for element checking */
100
101 /* Mesh -> BMesh */
102 void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
103 {
104         MVert *mvert;
105         BLI_array_declare(verts);
106         MEdge *medge;
107         MLoop *ml;
108         MPoly *mpoly;
109         KeyBlock *actkey, *block;
110         BMVert *v, **vt = NULL, **verts = NULL;
111         BMEdge *e, **fedges = NULL, **et = NULL;
112         BMFace *f;
113         BMLoop *l;
114         BLI_array_declare(fedges);
115         float (*keyco)[3] = NULL;
116         int *keyi;
117         int totuv, i, j;
118
119         /* free custom data */
120         /* this isnt needed in most cases but do just incase */
121         CustomData_free(&bm->vdata, bm->totvert);
122         CustomData_free(&bm->edata, bm->totedge);
123         CustomData_free(&bm->ldata, bm->totloop);
124         CustomData_free(&bm->pdata, bm->totface);
125
126         if (!me || !me->totvert) {
127                 if (me) { /*no verts? still copy customdata layout*/
128                         CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_ASSIGN, 0);
129                         CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_ASSIGN, 0);
130                         CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_ASSIGN, 0);
131                         CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_ASSIGN, 0);
132
133                         CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
134                         CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
135                         CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
136                         CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
137                 }
138                 return; /* sanity check */
139         }
140
141         vt = MEM_mallocN(sizeof(void **) * me->totvert, "mesh to bmesh vtable");
142
143         CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
144         CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
145         CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
146         CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
147
148         /* make sure uv layer names are consisten */
149         totuv = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
150         for (i = 0; i < totuv; i++) {
151                 int li = CustomData_get_layer_index_n(&bm->pdata, CD_MTEXPOLY, i);
152                 CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
153         }
154
155         if (!CustomData_has_layer(&bm->edata, CD_CREASE))
156                 CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
157
158         if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
159                 CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
160
161         if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
162                 CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
163
164         if ((act_key_nr != 0) && (me->key != NULL)) {
165                 actkey = BLI_findlink(&me->key->block, act_key_nr - 1);
166         }
167         else {
168                 actkey = NULL;
169         }
170
171         if (me->key) {
172                 CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
173
174                 /* check if we need to generate unique ids for the shapekeys.
175                  * this also exists in the file reading code, but is here for
176                  * a sanity check */
177                 if (!me->key->uidgen) {
178                         fprintf(stderr,
179                                 "%s had to generate shape key uid's in a situation we shouldn't need to! "
180                                 "(bmesh internal error)\n",
181                                 __func__);
182
183                         me->key->uidgen = 1;
184                         for (block = me->key->block.first; block; block = block->next) {
185                                 block->uid = me->key->uidgen++;
186                         }
187                 }
188
189                 if (actkey && actkey->totelem == me->totvert) {
190                         keyco = actkey->data;
191                         bm->shapenr = act_key_nr;
192                 }
193
194                 for (i = 0, block = me->key->block.first; block; block = block->next, i++) {
195                         CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
196                                                    CD_ASSIGN, NULL, 0, block->name);
197
198                         j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
199                         bm->vdata.layers[j].uid = block->uid;
200                 }
201         }
202
203         CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
204         CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
205         CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
206         CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
207
208         for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
209                 v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
210                 BM_elem_index_set(v, i); /* set_ok */
211                 vt[i] = v;
212
213                 /* transfer flag */
214                 v->head.hflag = BM_vert_flag_from_mflag(mvert->flag & ~SELECT);
215
216                 /* this is necessary for selection counts to work properly */
217                 if (mvert->flag & SELECT) {
218                         BM_vert_select_set(bm, v, TRUE);
219                 }
220
221                 normal_short_to_float_v3(v->no, mvert->no);
222
223                 BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
224
225                 /* Copy Custom Dat */
226                 CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
227
228                 /* set shapekey data */
229                 if (me->key) {
230                         /* set shape key original index */
231                         keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
232                         if (keyi) {
233                                 *keyi = i;
234                         }
235
236                         for (block = me->key->block.first, j = 0; block; block = block->next, j++) {
237                                 float *co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, j);
238
239                                 if (co) {
240                                         copy_v3_v3(co, ((float *)block->data) + 3 * i);
241                                 }
242                         }
243                 }
244         }
245
246         bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
247
248         if (!me->totedge) {
249                 MEM_freeN(vt);
250                 return;
251         }
252
253         et = MEM_mallocN(sizeof(void **) * me->totedge, "mesh to bmesh etable");
254
255         medge = me->medge;
256         for (i = 0; i < me->totedge; i++, medge++) {
257                 e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
258                 BM_elem_index_set(e, i); /* set_ok */
259                 et[i] = e;
260
261                 /* transfer flags */
262                 e->head.hflag = BM_edge_flag_from_mflag(medge->flag & ~SELECT);
263
264                 /* this is necessary for selection counts to work properly */
265                 if (medge->flag & SELECT) {
266                         BM_edge_select_set(bm, e, TRUE);
267                 }
268
269                 /* Copy Custom Data */
270                 CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
271
272                 BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
273                 BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
274         }
275
276         bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
277
278         mpoly = me->mpoly;
279         for (i = 0; i < me->totpoly; i++, mpoly++) {
280                 BMIter iter;
281
282                 BLI_array_empty(fedges);
283                 BLI_array_empty(verts);
284
285                 BLI_array_grow_items(fedges, mpoly->totloop);
286                 BLI_array_grow_items(verts, mpoly->totloop);
287
288                 for (j = 0; j < mpoly->totloop; j++) {
289                         ml = &me->mloop[mpoly->loopstart + j];
290                         v = vt[ml->v];
291                         e = et[ml->e];
292
293                         fedges[j] = e;
294                         verts[j] = v;
295                 }
296
297                 /* not sure what this block is supposed to do,
298                  * but its unused. so commenting - campbell */
299 #if 0
300                 {
301                         BMVert *v1, *v2;
302                         v1 = vt[me->mloop[mpoly->loopstart].v];
303                         v2 = vt[me->mloop[mpoly->loopstart + 1].v];
304
305                         if (v1 == fedges[0]->v1) {
306                                 v2 = fedges[0]->v2;
307                         }
308                         else {
309                                 v1 = fedges[0]->v2;
310                                 v2 = fedges[0]->v1;
311                         }
312                 }
313 #endif
314
315                 f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
316
317                 if (!f) {
318                         printf("%s: Warning! Bad face in mesh"
319                                " \"%s\" at index %d!, skipping\n",
320                                __func__, me->id.name + 2, i);
321                         continue;
322                 }
323
324                 /* don't use 'i' since we may have skipped the face */
325                 BM_elem_index_set(f, bm->totface - 1); /* set_ok */
326
327                 /* transfer flag */
328                 f->head.hflag = BM_face_flag_from_mflag(mpoly->flag & ~ME_FACE_SEL);
329
330                 /* this is necessary for selection counts to work properly */
331                 if (mpoly->flag & ME_FACE_SEL) {
332                         BM_face_select_set(bm, f, TRUE);
333                 }
334
335                 f->mat_nr = mpoly->mat_nr;
336                 if (i == me->act_face) bm->act_face = f;
337
338                 j = 0;
339                 BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, j) {
340                         /* Save index of correspsonding MLoop */
341                         BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
342                 }
343
344                 /* Copy Custom Data */
345                 CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
346         }
347
348         bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
349
350         {
351                 BMIter fiter;
352                 BMIter liter;
353
354                 /* Copy over loop CustomData. Doing this in a separate loop isn't necessary
355                  * but is an optimization, to avoid copying a bunch of interpolated customdata
356                  * for each BMLoop (from previous BMLoops using the same edge), always followed
357                  * by freeing the interpolated data and overwriting it with data from the Mesh. */
358                 BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
359                         BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
360                                 int li = BM_elem_index_get(l);
361                                 CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
362                                 BM_elem_index_set(l, 0); /* set_loop */
363                         }
364                 }
365         }
366
367         if (me->mselect && me->totselect != 0) {
368
369                 BMVert **vert_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
370                                                   "Selection Conversion Vertex Pointer Array");
371                 BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
372                                                   "Selection Conversion Edge Pointer Array");
373                 BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
374                                                   "Selection Conversion Face Pointer Array");
375
376                 BMIter  iter;
377                 BMVert  *vert;
378                 BMEdge  *edge;
379                 BMFace  *face;
380                 MSelect *msel;
381
382                 BM_ITER_MESH_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, i) { vert_array[i] = vert; }
383                 BM_ITER_MESH_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, i) { edge_array[i] = edge; }
384                 BM_ITER_MESH_INDEX (face, &iter, bm, BM_FACES_OF_MESH, i) { face_array[i] = face; }
385
386                 for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
387                         switch (msel->type) {
388                                 case ME_VSEL:
389                                         BM_select_history_store(bm, (BMElem *)vert_array[msel->index]);
390                                         break;
391                                 case ME_ESEL:
392                                         BM_select_history_store(bm, (BMElem *)edge_array[msel->index]);
393                                         break;
394                                 case ME_FSEL:
395                                         BM_select_history_store(bm, (BMElem *)face_array[msel->index]);
396                                         break;
397                         }
398                 }
399
400                 MEM_freeN(vert_array);
401                 MEM_freeN(edge_array);
402                 MEM_freeN(face_array);
403         }
404         else {
405                 me->totselect = 0;
406                 if (me->mselect) {
407                         MEM_freeN(me->mselect);
408                         me->mselect = NULL;
409                 }
410         }
411
412         BLI_array_free(fedges);
413         BLI_array_free(verts);
414
415         MEM_freeN(vt);
416         MEM_freeN(et);
417 }
418
419
420 /* BMesh -> Mesh */
421 static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
422 {
423         BMVert **vertMap = NULL;
424         BMVert *eve;
425         int index;
426         int i = 0;
427         BMIter iter;
428
429         /* caller needs to ensure this */
430         BLI_assert(ototvert > 0);
431
432         vertMap = MEM_callocN(sizeof(*vertMap) * ototvert, "vertMap");
433         if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
434                 int *keyi;
435                 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
436                         keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
437                         if (keyi) {
438                                 if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
439                                         vertMap[index] = eve;
440                                 }
441                         }
442                         else {
443                                 if (i < ototvert) {
444                                         vertMap[i] = eve;
445                                 }
446                         }
447                         i++;
448                 }
449         }
450         else {
451                 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
452                         if (i < ototvert) {
453                                 vertMap[i] = eve;
454                         }
455                         else {
456                                 break;
457                         }
458                         i++;
459                 }
460         }
461
462         return vertMap;
463 }
464
465 /**
466  * returns customdata shapekey index from a keyblock or -1
467  * \note could split this out into a more generic function */
468 static int bm_to_mesh_shape_layer_index_from_kb(BMesh *bm, KeyBlock *currkey)
469 {
470         int i;
471         int j = 0;
472
473         for (i = 0; i < bm->vdata.totlayer; i++) {
474                 if (bm->vdata.layers[i].type == CD_SHAPEKEY) {
475                         if (currkey->uid == bm->vdata.layers[i].uid) {
476                                 return j;
477                         }
478                         j++;
479                 }
480         }
481         return -1;
482 }
483
484 BLI_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
485 {
486         /* this is a cheap way to set the edge draw, its not precise and will
487          * pick the first 2 faces an edge uses.
488          * The dot comparison is a little arbitrary, but set so that a 5 subd
489          * IcoSphere won't vanish but subd 6 will (as with pre-bmesh blender) */
490
491
492         if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
493              (e->l && (e->l != e->l->radial_next)) &&
494              (dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.9995f))
495         {
496                 med->flag &= ~ME_EDGEDRAW;
497         }
498         else {
499                 med->flag |= ME_EDGEDRAW;
500         }
501 }
502
503 void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
504 {
505         MLoop *mloop;
506         MPoly *mpoly;
507         MVert *mvert, *oldverts;
508         MEdge *med, *medge;
509         BMVert *v, *eve;
510         BMEdge *e;
511         BMLoop *l;
512         BMFace *f;
513         BMIter iter, liter;
514         int i, j, ototvert;
515
516         ototvert = me->totvert;
517
518         /* new vertex block */
519         if (bm->totvert == 0) mvert = NULL;
520         else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
521
522         /* new edge block */
523         if (bm->totedge == 0) medge = NULL;
524         else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
525
526         /* new ngon face block */
527         if (bm->totface == 0) mpoly = NULL;
528         else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
529
530         /* new loop block */
531         if (bm->totloop == 0) mloop = NULL;
532         else mloop = MEM_callocN(bm->totloop * sizeof(MLoop), "loadeditbMesh loop");
533
534         /* lets save the old verts just in case we are actually working on
535          * a key ... we now do processing of the keys at the end */
536         oldverts = me->mvert;
537
538         /* don't free this yet */
539         CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
540
541         /* free custom data */
542         CustomData_free(&me->vdata, me->totvert);
543         CustomData_free(&me->edata, me->totedge);
544         CustomData_free(&me->fdata, me->totface);
545         CustomData_free(&me->ldata, me->totloop);
546         CustomData_free(&me->pdata, me->totpoly);
547
548         /* add new custom data */
549         me->totvert = bm->totvert;
550         me->totedge = bm->totedge;
551         me->totloop = bm->totloop;
552         me->totpoly = bm->totface;
553         /* will be overwritten with a valid value if 'dotess' is set, otherwise we
554          * end up with 'me->totface' and me->mface == NULL which can crash [#28625]
555          */
556         me->totface = 0;
557
558         CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
559         CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
560         CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
561         CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
562
563         CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
564         CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
565         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
566         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
567
568         /* this is called again, 'dotess' arg is used there */
569         mesh_update_customdata_pointers(me, 0);
570
571         i = 0;
572         BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
573                 float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
574
575                 mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
576
577                 copy_v3_v3(mvert->co, v->co);
578                 normal_float_to_short_v3(mvert->no, v->no);
579
580                 mvert->flag = BM_vert_flag_to_mflag(v);
581
582                 BM_elem_index_set(v, i); /* set_inline */
583
584                 /* copy over customdat */
585                 CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
586
587                 i++;
588                 mvert++;
589
590                 BM_CHECK_ELEMENT(v);
591         }
592         bm->elem_index_dirty &= ~BM_VERT;
593
594         med = medge;
595         i = 0;
596         BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
597                 float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
598                 float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
599
600                 med->v1 = BM_elem_index_get(e->v1);
601                 med->v2 = BM_elem_index_get(e->v2);
602                 med->crease = crease ? (char)((*crease) * 255) : 0;
603                 med->bweight = bweight ? (char)((*bweight) * 255) : 0;
604
605                 med->flag = BM_edge_flag_to_mflag(e);
606
607                 BM_elem_index_set(e, i); /* set_inline */
608
609                 /* copy over customdata */
610                 CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
611
612                 bmesh_quick_edgedraw_flag(med, e);
613
614                 i++;
615                 med++;
616                 BM_CHECK_ELEMENT(e);
617         }
618         bm->elem_index_dirty &= ~BM_EDGE;
619
620         i = 0;
621         j = 0;
622         BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
623                 mpoly->loopstart = j;
624                 mpoly->totloop = f->len;
625                 mpoly->mat_nr = f->mat_nr;
626                 mpoly->flag = BM_face_flag_to_mflag(f);
627
628                 l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
629                 for ( ; l; l = BM_iter_step(&liter), j++, mloop++) {
630                         mloop->e = BM_elem_index_get(l->e);
631                         mloop->v = BM_elem_index_get(l->v);
632
633                         /* copy over customdat */
634                         CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
635                         BM_CHECK_ELEMENT(l);
636                         BM_CHECK_ELEMENT(l->e);
637                         BM_CHECK_ELEMENT(l->v);
638                 }
639
640                 if (f == bm->act_face) me->act_face = i;
641
642                 /* copy over customdata */
643                 CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
644
645                 i++;
646                 mpoly++;
647                 BM_CHECK_ELEMENT(f);
648         }
649
650         /* patch hook indices and vertex parents */
651         if (ototvert > 0) {
652                 Object *ob;
653                 ModifierData *md;
654                 BMVert **vertMap = NULL;
655                 int i, j;
656
657                 for (ob = G.main->object.first; ob; ob = ob->id.next) {
658                         if ((ob->parent) && (ob->parent->data == me) && ELEM(ob->partype, PARVERT1, PARVERT3)) {
659
660                                 if (vertMap == NULL) {
661                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
662                                 }
663
664                                 if (ob->par1 < ototvert) {
665                                         eve = vertMap[ob->par1];
666                                         if (eve) ob->par1 = BM_elem_index_get(eve);
667                                 }
668                                 if (ob->par2 < ototvert) {
669                                         eve = vertMap[ob->par2];
670                                         if (eve) ob->par2 = BM_elem_index_get(eve);
671                                 }
672                                 if (ob->par3 < ototvert) {
673                                         eve = vertMap[ob->par3];
674                                         if (eve) ob->par3 = BM_elem_index_get(eve);
675                                 }
676
677                         }
678                         if (ob->data == me) {
679                                 for (md = ob->modifiers.first; md; md = md->next) {
680                                         if (md->type == eModifierType_Hook) {
681                                                 HookModifierData *hmd = (HookModifierData *) md;
682
683                                                 if (vertMap == NULL) {
684                                                         vertMap = bm_to_mesh_vertex_map(bm, ototvert);
685                                                 }
686
687                                                 for (i = j = 0; i < hmd->totindex; i++) {
688                                                         if (hmd->indexar[i] < ototvert) {
689                                                                 eve = vertMap[hmd->indexar[i]];
690
691                                                                 if (eve) {
692                                                                         hmd->indexar[j++] = BM_elem_index_get(eve);
693                                                                 }
694                                                         }
695                                                         else j++;
696                                                 }
697
698                                                 hmd->totindex = j;
699                                         }
700                                 }
701                         }
702                 }
703
704                 if (vertMap) MEM_freeN(vertMap);
705         }
706
707         if (dotess) {
708                 BKE_mesh_tessface_calc(me);
709         }
710
711         mesh_update_customdata_pointers(me, dotess);
712
713         {
714                 BMEditSelection *selected;
715                 me->totselect = BLI_countlist(&(bm->selected));
716
717                 if (me->mselect) MEM_freeN(me->mselect);
718
719                 me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
720
721
722                 for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
723                         if (selected->htype == BM_VERT) {
724                                 me->mselect[i].type = ME_VSEL;
725
726                         }
727                         else if (selected->htype == BM_EDGE) {
728                                 me->mselect[i].type = ME_ESEL;
729
730                         }
731                         else if (selected->htype == BM_FACE) {
732                                 me->mselect[i].type = ME_FSEL;
733                         }
734
735                         me->mselect[i].index = BM_elem_index_get(selected->ele);
736                 }
737         }
738
739         /* see comment below, this logic is in twice */
740
741         if (me->key) {
742                 KeyBlock *currkey;
743                 KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
744
745                 float (*ofs)[3] = NULL;
746
747                 /* go through and find any shapekey customdata layers
748                  * that might not have corresponding KeyBlocks, and add them if
749                  * necessary */
750                 j = 0;
751                 for (i = 0; i < bm->vdata.totlayer; i++) {
752                         if (bm->vdata.layers[i].type != CD_SHAPEKEY)
753                                 continue;
754
755                         for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
756                                 if (currkey->uid == bm->vdata.layers[i].uid)
757                                         break;
758                         }
759
760                         if (!currkey) {
761                                 currkey = add_keyblock(me->key, bm->vdata.layers[i].name);
762                                 currkey->uid = bm->vdata.layers[i].uid;
763                         }
764
765                         j++;
766                 }
767
768
769                 /* editing the base key should update others */
770                 if ((me->key->type == KEY_RELATIVE) && /* only need offsets for relative shape keys */
771                     (actkey   != NULL) &&              /* unlikely, but the active key may not be valid if the
772                                                         * bmesh and the mesh are out of sync */
773                     (oldverts != NULL))                /* not used here, but 'oldverts' is used later for applying 'ofs' */
774                 {
775                         int act_is_basis = FALSE;
776
777                         /* find if this key is a basis for any others */
778                         for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
779                                 if (bm->shapenr - 1 == currkey->relative) {
780                                         act_is_basis = TRUE;
781                                         break;
782                                 }
783                         }
784
785                         if (act_is_basis) { /* active key is a base */
786                                 float (*fp)[3] = actkey->data;
787                                 int *keyi;
788
789                                 ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
790                                 mvert = me->mvert;
791                                 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
792                                         keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
793                                         if (keyi && *keyi != ORIGINDEX_NONE) {
794                                                 sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
795                                         }
796                                         mvert++;
797                                 }
798                         }
799                 }
800
801                 for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
802                         int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
803                         int *keyi;
804                         float (*ofs_pt)[3] = ofs;
805                         float *newkey, *oldkey, *fp;
806
807                         j = bm_to_mesh_shape_layer_index_from_kb(bm, currkey);
808
809
810                         fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert,  "currkey->data");
811                         oldkey = currkey->data;
812
813                         mvert = me->mvert;
814                         BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
815
816                                 if (currkey == actkey) {
817                                         copy_v3_v3(fp, eve->co);
818
819                                         if (actkey != me->key->refkey) { /* important see bug [#30771] */
820                                                 if (oldverts) {
821                                                         keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
822                                                         if (*keyi != ORIGINDEX_NONE && *keyi < currkey->totelem) { /* valid old vertex */
823                                                                 copy_v3_v3(mvert->co, oldverts[*keyi].co);
824                                                         }
825                                                 }
826                                         }
827                                 }
828                                 else if (j != -1) {
829                                         /* in most cases this runs */
830                                         copy_v3_v3(fp, CustomData_bmesh_get_n(&bm->vdata, eve->head.data, CD_SHAPEKEY, j));
831                                 }
832                                 else if (oldkey &&
833                                          (keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX)) &&
834                                          (*keyi != ORIGINDEX_NONE && *keyi < currkey->totelem))
835                                 {
836                                         /* old method of reconstructing keys via vertice's original key indices,
837                                          * currently used if the new method above fails (which is theoretically
838                                          * possible in certain cases of undo) */
839                                         copy_v3_v3(fp, &oldkey[3 * (*keyi)]);
840                                 }
841                                 else {
842                                         /* fail! fill in with dummy value */
843                                         copy_v3_v3(fp, mvert->co);
844                                 }
845
846                                 /* propagate edited basis offsets to other shapes */
847                                 if (apply_offset) {
848                                         add_v3_v3(fp, *ofs_pt++);
849                                 }
850
851                                 fp += 3;
852                                 mvert++;
853                         }
854
855                         currkey->totelem = bm->totvert;
856                         if (currkey->data) {
857                                 MEM_freeN(currkey->data);
858                         }
859                         currkey->data = newkey;
860                 }
861
862                 if (ofs) MEM_freeN(ofs);
863         }
864
865         if (oldverts) MEM_freeN(oldverts);
866
867         /* topology could be changed, ensure mdisps are ok */
868         multires_topology_changed(me);
869 }