0402524e03d2d2ec2d582022f6e650fb26a58682
[blender.git] / source / blender / blenkernel / intern / mesh_convert.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 bke
19  */
20
21 #include "CLG_log.h"
22
23 #include "MEM_guardedalloc.h"
24
25 #include "DNA_scene_types.h"
26 #include "DNA_key_types.h"
27 #include "DNA_material_types.h"
28 #include "DNA_meta_types.h"
29 #include "DNA_object_types.h"
30 #include "DNA_mesh_types.h"
31 #include "DNA_curve_types.h"
32
33 #include "BLI_utildefines.h"
34 #include "BLI_math.h"
35 #include "BLI_listbase.h"
36 #include "BLI_edgehash.h"
37
38 #include "BKE_main.h"
39 #include "BKE_DerivedMesh.h"
40 #include "BKE_key.h"
41 #include "BKE_mesh.h"
42 #include "BKE_mesh_runtime.h"
43 #include "BKE_modifier.h"
44 #include "BKE_displist.h"
45 #include "BKE_library.h"
46 #include "BKE_material.h"
47 #include "BKE_mball.h"
48 /* these 2 are only used by conversion functions */
49 #include "BKE_curve.h"
50 /* -- */
51 #include "BKE_object.h"
52
53 #include "DEG_depsgraph.h"
54 #include "DEG_depsgraph_query.h"
55
56 /* Define for cases when you want extra validation of mesh
57  * after certain modifications.
58  */
59 // #undef VALIDATE_MESH
60
61 #ifdef VALIDATE_MESH
62 #  define ASSERT_IS_VALID_MESH(mesh) \
63     (BLI_assert((mesh == NULL) || (BKE_mesh_is_valid(mesh) == true)))
64 #else
65 #  define ASSERT_IS_VALID_MESH(mesh)
66 #endif
67
68 static CLG_LogRef LOG = {"bke.mesh_convert"};
69
70 void BKE_mesh_from_metaball(ListBase *lb, Mesh *me)
71 {
72   DispList *dl;
73   MVert *mvert;
74   MLoop *mloop, *allloop;
75   MPoly *mpoly;
76   const float *nors, *verts;
77   int a, *index;
78
79   dl = lb->first;
80   if (dl == NULL) {
81     return;
82   }
83
84   if (dl->type == DL_INDEX4) {
85     mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, dl->nr);
86     allloop = mloop = CustomData_add_layer(&me->ldata, CD_MLOOP, CD_CALLOC, NULL, dl->parts * 4);
87     mpoly = CustomData_add_layer(&me->pdata, CD_MPOLY, CD_CALLOC, NULL, dl->parts);
88     me->mvert = mvert;
89     me->mloop = mloop;
90     me->mpoly = mpoly;
91     me->totvert = dl->nr;
92     me->totpoly = dl->parts;
93
94     a = dl->nr;
95     nors = dl->nors;
96     verts = dl->verts;
97     while (a--) {
98       copy_v3_v3(mvert->co, verts);
99       normal_float_to_short_v3(mvert->no, nors);
100       mvert++;
101       nors += 3;
102       verts += 3;
103     }
104
105     a = dl->parts;
106     index = dl->index;
107     while (a--) {
108       int count = index[2] != index[3] ? 4 : 3;
109
110       mloop[0].v = index[0];
111       mloop[1].v = index[1];
112       mloop[2].v = index[2];
113       if (count == 4) {
114         mloop[3].v = index[3];
115       }
116
117       mpoly->totloop = count;
118       mpoly->loopstart = (int)(mloop - allloop);
119       mpoly->flag = ME_SMOOTH;
120
121       mpoly++;
122       mloop += count;
123       me->totloop += count;
124       index += 4;
125     }
126
127     BKE_mesh_update_customdata_pointers(me, true);
128
129     BKE_mesh_calc_normals(me);
130
131     BKE_mesh_calc_edges(me, true, false);
132   }
133 }
134
135 /**
136  * Specialized function to use when we _know_ existing edges don't overlap with poly edges.
137  */
138 static void make_edges_mdata_extend(
139     MEdge **r_alledge, int *r_totedge, const MPoly *mpoly, MLoop *mloop, const int totpoly)
140 {
141   int totedge = *r_totedge;
142   int totedge_new;
143   EdgeHash *eh;
144   unsigned int eh_reserve;
145   const MPoly *mp;
146   int i;
147
148   eh_reserve = max_ii(totedge, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(totpoly));
149   eh = BLI_edgehash_new_ex(__func__, eh_reserve);
150
151   for (i = 0, mp = mpoly; i < totpoly; i++, mp++) {
152     BKE_mesh_poly_edgehash_insert(eh, mp, mloop + mp->loopstart);
153   }
154
155   totedge_new = BLI_edgehash_len(eh);
156
157 #ifdef DEBUG
158   /* ensure that there's no overlap! */
159   if (totedge_new) {
160     MEdge *medge = *r_alledge;
161     for (i = 0; i < totedge; i++, medge++) {
162       BLI_assert(BLI_edgehash_haskey(eh, medge->v1, medge->v2) == false);
163     }
164   }
165 #endif
166
167   if (totedge_new) {
168     EdgeHashIterator *ehi;
169     MEdge *medge;
170     unsigned int e_index = totedge;
171
172     *r_alledge = medge = (*r_alledge ?
173                               MEM_reallocN(*r_alledge, sizeof(MEdge) * (totedge + totedge_new)) :
174                               MEM_calloc_arrayN(totedge_new, sizeof(MEdge), __func__));
175     medge += totedge;
176
177     totedge += totedge_new;
178
179     /* --- */
180     for (ehi = BLI_edgehashIterator_new(eh); BLI_edgehashIterator_isDone(ehi) == false;
181          BLI_edgehashIterator_step(ehi), ++medge, e_index++) {
182       BLI_edgehashIterator_getKey(ehi, &medge->v1, &medge->v2);
183       BLI_edgehashIterator_setValue(ehi, POINTER_FROM_UINT(e_index));
184
185       medge->crease = medge->bweight = 0;
186       medge->flag = ME_EDGEDRAW | ME_EDGERENDER;
187     }
188     BLI_edgehashIterator_free(ehi);
189
190     *r_totedge = totedge;
191
192     for (i = 0, mp = mpoly; i < totpoly; i++, mp++) {
193       MLoop *l = &mloop[mp->loopstart];
194       MLoop *l_prev = (l + (mp->totloop - 1));
195       int j;
196       for (j = 0; j < mp->totloop; j++, l++) {
197         /* lookup hashed edge index */
198         l_prev->e = POINTER_AS_UINT(BLI_edgehash_lookup(eh, l_prev->v, l->v));
199         l_prev = l;
200       }
201     }
202   }
203
204   BLI_edgehash_free(eh, NULL);
205 }
206
207 /* Initialize mverts, medges and, faces for converting nurbs to mesh and derived mesh */
208 /* return non-zero on error */
209 int BKE_mesh_nurbs_to_mdata(Object *ob,
210                             MVert **r_allvert,
211                             int *r_totvert,
212                             MEdge **r_alledge,
213                             int *r_totedge,
214                             MLoop **r_allloop,
215                             MPoly **r_allpoly,
216                             int *r_totloop,
217                             int *r_totpoly)
218 {
219   ListBase disp = {NULL, NULL};
220
221   if (ob->runtime.curve_cache) {
222     disp = ob->runtime.curve_cache->disp;
223   }
224
225   return BKE_mesh_nurbs_displist_to_mdata(ob,
226                                           &disp,
227                                           r_allvert,
228                                           r_totvert,
229                                           r_alledge,
230                                           r_totedge,
231                                           r_allloop,
232                                           r_allpoly,
233                                           NULL,
234                                           r_totloop,
235                                           r_totpoly);
236 }
237
238 /* BMESH: this doesn't calculate all edges from polygons,
239  * only free standing edges are calculated */
240
241 /* Initialize mverts, medges and, faces for converting nurbs to mesh and derived mesh */
242 /* use specified dispbase */
243 int BKE_mesh_nurbs_displist_to_mdata(Object *ob,
244                                      const ListBase *dispbase,
245                                      MVert **r_allvert,
246                                      int *r_totvert,
247                                      MEdge **r_alledge,
248                                      int *r_totedge,
249                                      MLoop **r_allloop,
250                                      MPoly **r_allpoly,
251                                      MLoopUV **r_alluv,
252                                      int *r_totloop,
253                                      int *r_totpoly)
254 {
255   Curve *cu = ob->data;
256   DispList *dl;
257   MVert *mvert;
258   MPoly *mpoly;
259   MLoop *mloop;
260   MLoopUV *mloopuv = NULL;
261   MEdge *medge;
262   const float *data;
263   int a, b, ofs, vertcount, startvert, totvert = 0, totedge = 0, totloop = 0, totpoly = 0;
264   int p1, p2, p3, p4, *index;
265   const bool conv_polys = ((CU_DO_2DFILL(cu) ==
266                             false) || /* 2d polys are filled with DL_INDEX3 displists */
267                            (ob->type == OB_SURF)); /* surf polys are never filled */
268
269   /* count */
270   dl = dispbase->first;
271   while (dl) {
272     if (dl->type == DL_SEGM) {
273       totvert += dl->parts * dl->nr;
274       totedge += dl->parts * (dl->nr - 1);
275     }
276     else if (dl->type == DL_POLY) {
277       if (conv_polys) {
278         totvert += dl->parts * dl->nr;
279         totedge += dl->parts * dl->nr;
280       }
281     }
282     else if (dl->type == DL_SURF) {
283       int tot;
284       totvert += dl->parts * dl->nr;
285       tot = (dl->parts - 1 + ((dl->flag & DL_CYCL_V) == 2)) *
286             (dl->nr - 1 + (dl->flag & DL_CYCL_U));
287       totpoly += tot;
288       totloop += tot * 4;
289     }
290     else if (dl->type == DL_INDEX3) {
291       int tot;
292       totvert += dl->nr;
293       tot = dl->parts;
294       totpoly += tot;
295       totloop += tot * 3;
296     }
297     dl = dl->next;
298   }
299
300   if (totvert == 0) {
301     /* error("can't convert"); */
302     /* Make Sure you check ob->data is a curve */
303     return -1;
304   }
305
306   *r_allvert = mvert = MEM_calloc_arrayN(totvert, sizeof(MVert), "nurbs_init mvert");
307   *r_alledge = medge = MEM_calloc_arrayN(totedge, sizeof(MEdge), "nurbs_init medge");
308   *r_allloop = mloop = MEM_calloc_arrayN(
309       totpoly, 4 * sizeof(MLoop), "nurbs_init mloop");  // totloop
310   *r_allpoly = mpoly = MEM_calloc_arrayN(totpoly, sizeof(MPoly), "nurbs_init mloop");
311
312   if (r_alluv) {
313     *r_alluv = mloopuv = MEM_calloc_arrayN(totpoly, 4 * sizeof(MLoopUV), "nurbs_init mloopuv");
314   }
315
316   /* verts and faces */
317   vertcount = 0;
318
319   dl = dispbase->first;
320   while (dl) {
321     const bool is_smooth = (dl->rt & CU_SMOOTH) != 0;
322
323     if (dl->type == DL_SEGM) {
324       startvert = vertcount;
325       a = dl->parts * dl->nr;
326       data = dl->verts;
327       while (a--) {
328         copy_v3_v3(mvert->co, data);
329         data += 3;
330         vertcount++;
331         mvert++;
332       }
333
334       for (a = 0; a < dl->parts; a++) {
335         ofs = a * dl->nr;
336         for (b = 1; b < dl->nr; b++) {
337           medge->v1 = startvert + ofs + b - 1;
338           medge->v2 = startvert + ofs + b;
339           medge->flag = ME_LOOSEEDGE | ME_EDGERENDER | ME_EDGEDRAW;
340
341           medge++;
342         }
343       }
344     }
345     else if (dl->type == DL_POLY) {
346       if (conv_polys) {
347         startvert = vertcount;
348         a = dl->parts * dl->nr;
349         data = dl->verts;
350         while (a--) {
351           copy_v3_v3(mvert->co, data);
352           data += 3;
353           vertcount++;
354           mvert++;
355         }
356
357         for (a = 0; a < dl->parts; a++) {
358           ofs = a * dl->nr;
359           for (b = 0; b < dl->nr; b++) {
360             medge->v1 = startvert + ofs + b;
361             if (b == dl->nr - 1) {
362               medge->v2 = startvert + ofs;
363             }
364             else {
365               medge->v2 = startvert + ofs + b + 1;
366             }
367             medge->flag = ME_LOOSEEDGE | ME_EDGERENDER | ME_EDGEDRAW;
368             medge++;
369           }
370         }
371       }
372     }
373     else if (dl->type == DL_INDEX3) {
374       startvert = vertcount;
375       a = dl->nr;
376       data = dl->verts;
377       while (a--) {
378         copy_v3_v3(mvert->co, data);
379         data += 3;
380         vertcount++;
381         mvert++;
382       }
383
384       a = dl->parts;
385       index = dl->index;
386       while (a--) {
387         mloop[0].v = startvert + index[0];
388         mloop[1].v = startvert + index[2];
389         mloop[2].v = startvert + index[1];
390         mpoly->loopstart = (int)(mloop - (*r_allloop));
391         mpoly->totloop = 3;
392         mpoly->mat_nr = dl->col;
393
394         if (mloopuv) {
395           int i;
396
397           for (i = 0; i < 3; i++, mloopuv++) {
398             mloopuv->uv[0] = (mloop[i].v - startvert) / (float)(dl->nr - 1);
399             mloopuv->uv[1] = 0.0f;
400           }
401         }
402
403         if (is_smooth) {
404           mpoly->flag |= ME_SMOOTH;
405         }
406         mpoly++;
407         mloop += 3;
408         index += 3;
409       }
410     }
411     else if (dl->type == DL_SURF) {
412       startvert = vertcount;
413       a = dl->parts * dl->nr;
414       data = dl->verts;
415       while (a--) {
416         copy_v3_v3(mvert->co, data);
417         data += 3;
418         vertcount++;
419         mvert++;
420       }
421
422       for (a = 0; a < dl->parts; a++) {
423
424         if ((dl->flag & DL_CYCL_V) == 0 && a == dl->parts - 1) {
425           break;
426         }
427
428         if (dl->flag & DL_CYCL_U) {    /* p2 -> p1 -> */
429           p1 = startvert + dl->nr * a; /* p4 -> p3 -> */
430           p2 = p1 + dl->nr - 1;        /* -----> next row */
431           p3 = p1 + dl->nr;
432           p4 = p2 + dl->nr;
433           b = 0;
434         }
435         else {
436           p2 = startvert + dl->nr * a;
437           p1 = p2 + 1;
438           p4 = p2 + dl->nr;
439           p3 = p1 + dl->nr;
440           b = 1;
441         }
442         if ((dl->flag & DL_CYCL_V) && a == dl->parts - 1) {
443           p3 -= dl->parts * dl->nr;
444           p4 -= dl->parts * dl->nr;
445         }
446
447         for (; b < dl->nr; b++) {
448           mloop[0].v = p1;
449           mloop[1].v = p3;
450           mloop[2].v = p4;
451           mloop[3].v = p2;
452           mpoly->loopstart = (int)(mloop - (*r_allloop));
453           mpoly->totloop = 4;
454           mpoly->mat_nr = dl->col;
455
456           if (mloopuv) {
457             int orco_sizeu = dl->nr - 1;
458             int orco_sizev = dl->parts - 1;
459             int i;
460
461             /* exception as handled in convertblender.c too */
462             if (dl->flag & DL_CYCL_U) {
463               orco_sizeu++;
464               if (dl->flag & DL_CYCL_V) {
465                 orco_sizev++;
466               }
467             }
468             else if (dl->flag & DL_CYCL_V) {
469               orco_sizev++;
470             }
471
472             for (i = 0; i < 4; i++, mloopuv++) {
473               /* find uv based on vertex index into grid array */
474               int v = mloop[i].v - startvert;
475
476               mloopuv->uv[0] = (v / dl->nr) / (float)orco_sizev;
477               mloopuv->uv[1] = (v % dl->nr) / (float)orco_sizeu;
478
479               /* cyclic correction */
480               if ((i == 1 || i == 2) && mloopuv->uv[0] == 0.0f) {
481                 mloopuv->uv[0] = 1.0f;
482               }
483               if ((i == 0 || i == 1) && mloopuv->uv[1] == 0.0f) {
484                 mloopuv->uv[1] = 1.0f;
485               }
486             }
487           }
488
489           if (is_smooth) {
490             mpoly->flag |= ME_SMOOTH;
491           }
492           mpoly++;
493           mloop += 4;
494
495           p4 = p3;
496           p3++;
497           p2 = p1;
498           p1++;
499         }
500       }
501     }
502
503     dl = dl->next;
504   }
505
506   if (totpoly) {
507     make_edges_mdata_extend(r_alledge, &totedge, *r_allpoly, *r_allloop, totpoly);
508   }
509
510   *r_totpoly = totpoly;
511   *r_totloop = totloop;
512   *r_totedge = totedge;
513   *r_totvert = totvert;
514
515   return 0;
516 }
517
518 Mesh *BKE_mesh_new_nomain_from_curve_displist(Object *ob, ListBase *dispbase)
519 {
520   Curve *cu = ob->data;
521   Mesh *mesh;
522   MVert *allvert;
523   MEdge *alledge;
524   MLoop *allloop;
525   MPoly *allpoly;
526   MLoopUV *alluv = NULL;
527   int totvert, totedge, totloop, totpoly;
528   bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
529
530   if (BKE_mesh_nurbs_displist_to_mdata(ob,
531                                        dispbase,
532                                        &allvert,
533                                        &totvert,
534                                        &alledge,
535                                        &totedge,
536                                        &allloop,
537                                        &allpoly,
538                                        (use_orco_uv) ? &alluv : NULL,
539                                        &totloop,
540                                        &totpoly) != 0) {
541     /* Error initializing mdata. This often happens when curve is empty */
542     return BKE_mesh_new_nomain(0, 0, 0, 0, 0);
543   }
544
545   mesh = BKE_mesh_new_nomain(totvert, totedge, 0, totloop, totpoly);
546   mesh->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
547
548   memcpy(mesh->mvert, allvert, totvert * sizeof(MVert));
549   memcpy(mesh->medge, alledge, totedge * sizeof(MEdge));
550   memcpy(mesh->mloop, allloop, totloop * sizeof(MLoop));
551   memcpy(mesh->mpoly, allpoly, totpoly * sizeof(MPoly));
552
553   if (alluv) {
554     const char *uvname = "Orco";
555     CustomData_add_layer_named(&mesh->ldata, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
556   }
557
558   MEM_freeN(allvert);
559   MEM_freeN(alledge);
560   MEM_freeN(allloop);
561   MEM_freeN(allpoly);
562
563   return mesh;
564 }
565
566 Mesh *BKE_mesh_new_nomain_from_curve(Object *ob)
567 {
568   ListBase disp = {NULL, NULL};
569
570   if (ob->runtime.curve_cache) {
571     disp = ob->runtime.curve_cache->disp;
572   }
573
574   return BKE_mesh_new_nomain_from_curve_displist(ob, &disp);
575 }
576
577 /* this may fail replacing ob->data, be sure to check ob->type */
578 void BKE_mesh_from_nurbs_displist(Main *bmain,
579                                   Object *ob,
580                                   ListBase *dispbase,
581                                   const bool use_orco_uv,
582                                   const char *obdata_name,
583                                   bool temporary)
584 {
585   Object *ob1;
586   Mesh *me_eval = ob->runtime.mesh_eval;
587   Mesh *me;
588   Curve *cu;
589   MVert *allvert = NULL;
590   MEdge *alledge = NULL;
591   MLoop *allloop = NULL;
592   MLoopUV *alluv = NULL;
593   MPoly *allpoly = NULL;
594   int totvert, totedge, totloop, totpoly;
595
596   cu = ob->data;
597
598   if (me_eval == NULL) {
599     if (BKE_mesh_nurbs_displist_to_mdata(ob,
600                                          dispbase,
601                                          &allvert,
602                                          &totvert,
603                                          &alledge,
604                                          &totedge,
605                                          &allloop,
606                                          &allpoly,
607                                          (use_orco_uv) ? &alluv : NULL,
608                                          &totloop,
609                                          &totpoly) != 0) {
610       /* Error initializing */
611       return;
612     }
613
614     /* make mesh */
615     me = BKE_mesh_add(bmain, obdata_name);
616     me->totvert = totvert;
617     me->totedge = totedge;
618     me->totloop = totloop;
619     me->totpoly = totpoly;
620
621     me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, allvert, me->totvert);
622     me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, alledge, me->totedge);
623     me->mloop = CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, allloop, me->totloop);
624     me->mpoly = CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, allpoly, me->totpoly);
625
626     if (alluv) {
627       const char *uvname = "Orco";
628       me->mloopuv = CustomData_add_layer_named(
629           &me->ldata, CD_MLOOPUV, CD_ASSIGN, alluv, me->totloop, uvname);
630     }
631
632     BKE_mesh_calc_normals(me);
633   }
634   else {
635     me = BKE_mesh_add(bmain, obdata_name);
636     ob->runtime.mesh_eval = NULL;
637     BKE_mesh_nomain_to_mesh(me_eval, me, ob, &CD_MASK_MESH, true);
638   }
639
640   me->totcol = cu->totcol;
641   me->mat = cu->mat;
642
643   /* Copy evaluated texture space from curve to mesh.
644    *
645    * Note that we disable auto texture space feature since that will cause
646    * texture space to evaluate differently for curve and mesh, since curve
647    * uses CV to calculate bounding box, and mesh uses what is coming from
648    * tessellated curve.
649    */
650   me->texflag = cu->texflag & ~CU_AUTOSPACE;
651   copy_v3_v3(me->loc, cu->loc);
652   copy_v3_v3(me->size, cu->size);
653   copy_v3_v3(me->rot, cu->rot);
654   BKE_mesh_texspace_calc(me);
655
656   cu->mat = NULL;
657   cu->totcol = 0;
658
659   /* Do not decrement ob->data usercount here,
660    * it's done at end of func with BKE_id_free_us() call. */
661   ob->data = me;
662   ob->type = OB_MESH;
663
664   /* other users */
665   ob1 = bmain->objects.first;
666   while (ob1) {
667     if (ob1->data == cu) {
668       ob1->type = OB_MESH;
669
670       id_us_min((ID *)ob1->data);
671       ob1->data = ob->data;
672       id_us_plus((ID *)ob1->data);
673     }
674     ob1 = ob1->id.next;
675   }
676
677   if (temporary) {
678     /* For temporary objects in BKE_mesh_new_from_object don't remap
679      * the entire scene with associated depsgraph updates, which are
680      * problematic for renderers exporting data. */
681     BKE_id_free(NULL, cu);
682   }
683   else {
684     BKE_id_free_us(bmain, cu);
685   }
686 }
687
688 void BKE_mesh_from_nurbs(Main *bmain, Object *ob)
689 {
690   Curve *cu = (Curve *)ob->data;
691   bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
692   ListBase disp = {NULL, NULL};
693
694   if (ob->runtime.curve_cache) {
695     disp = ob->runtime.curve_cache->disp;
696   }
697
698   BKE_mesh_from_nurbs_displist(bmain, ob, &disp, use_orco_uv, cu->id.name, false);
699 }
700
701 typedef struct EdgeLink {
702   struct EdgeLink *next, *prev;
703   void *edge;
704 } EdgeLink;
705
706 typedef struct VertLink {
707   Link *next, *prev;
708   unsigned int index;
709 } VertLink;
710
711 static void prependPolyLineVert(ListBase *lb, unsigned int index)
712 {
713   VertLink *vl = MEM_callocN(sizeof(VertLink), "VertLink");
714   vl->index = index;
715   BLI_addhead(lb, vl);
716 }
717
718 static void appendPolyLineVert(ListBase *lb, unsigned int index)
719 {
720   VertLink *vl = MEM_callocN(sizeof(VertLink), "VertLink");
721   vl->index = index;
722   BLI_addtail(lb, vl);
723 }
724
725 void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int edge_users_test)
726 {
727   MVert *mvert = me->mvert;
728   MEdge *med, *medge = me->medge;
729   MPoly *mp, *mpoly = me->mpoly;
730   MLoop *mloop = me->mloop;
731
732   int medge_len = me->totedge;
733   int mpoly_len = me->totpoly;
734   int totedges = 0;
735   int i;
736
737   /* only to detect edge polylines */
738   int *edge_users;
739
740   ListBase edges = {NULL, NULL};
741
742   /* get boundary edges */
743   edge_users = MEM_calloc_arrayN(medge_len, sizeof(int), __func__);
744   for (i = 0, mp = mpoly; i < mpoly_len; i++, mp++) {
745     MLoop *ml = &mloop[mp->loopstart];
746     int j;
747     for (j = 0; j < mp->totloop; j++, ml++) {
748       edge_users[ml->e]++;
749     }
750   }
751
752   /* create edges from all faces (so as to find edges not in any faces) */
753   med = medge;
754   for (i = 0; i < medge_len; i++, med++) {
755     if (edge_users[i] == edge_users_test) {
756       EdgeLink *edl = MEM_callocN(sizeof(EdgeLink), "EdgeLink");
757       edl->edge = med;
758
759       BLI_addtail(&edges, edl);
760       totedges++;
761     }
762   }
763   MEM_freeN(edge_users);
764
765   if (edges.first) {
766     while (edges.first) {
767       /* each iteration find a polyline and add this as a nurbs poly spline */
768
769       ListBase polyline = {NULL, NULL}; /* store a list of VertLink's */
770       bool closed = false;
771       int totpoly = 0;
772       MEdge *med_current = ((EdgeLink *)edges.last)->edge;
773       unsigned int startVert = med_current->v1;
774       unsigned int endVert = med_current->v2;
775       bool ok = true;
776
777       appendPolyLineVert(&polyline, startVert);
778       totpoly++;
779       appendPolyLineVert(&polyline, endVert);
780       totpoly++;
781       BLI_freelinkN(&edges, edges.last);
782       totedges--;
783
784       while (ok) { /* while connected edges are found... */
785         EdgeLink *edl = edges.last;
786         ok = false;
787         while (edl) {
788           EdgeLink *edl_prev = edl->prev;
789
790           med = edl->edge;
791
792           if (med->v1 == endVert) {
793             endVert = med->v2;
794             appendPolyLineVert(&polyline, med->v2);
795             totpoly++;
796             BLI_freelinkN(&edges, edl);
797             totedges--;
798             ok = true;
799           }
800           else if (med->v2 == endVert) {
801             endVert = med->v1;
802             appendPolyLineVert(&polyline, endVert);
803             totpoly++;
804             BLI_freelinkN(&edges, edl);
805             totedges--;
806             ok = true;
807           }
808           else if (med->v1 == startVert) {
809             startVert = med->v2;
810             prependPolyLineVert(&polyline, startVert);
811             totpoly++;
812             BLI_freelinkN(&edges, edl);
813             totedges--;
814             ok = true;
815           }
816           else if (med->v2 == startVert) {
817             startVert = med->v1;
818             prependPolyLineVert(&polyline, startVert);
819             totpoly++;
820             BLI_freelinkN(&edges, edl);
821             totedges--;
822             ok = true;
823           }
824
825           edl = edl_prev;
826         }
827       }
828
829       /* Now we have a polyline, make into a curve */
830       if (startVert == endVert) {
831         BLI_freelinkN(&polyline, polyline.last);
832         totpoly--;
833         closed = true;
834       }
835
836       /* --- nurbs --- */
837       {
838         Nurb *nu;
839         BPoint *bp;
840         VertLink *vl;
841
842         /* create new 'nurb' within the curve */
843         nu = (Nurb *)MEM_callocN(sizeof(Nurb), "MeshNurb");
844
845         nu->pntsu = totpoly;
846         nu->pntsv = 1;
847         nu->orderu = 4;
848         nu->flagu = CU_NURB_ENDPOINT | (closed ? CU_NURB_CYCLIC : 0); /* endpoint */
849         nu->resolu = 12;
850
851         nu->bp = (BPoint *)MEM_calloc_arrayN(totpoly, sizeof(BPoint), "bpoints");
852
853         /* add points */
854         vl = polyline.first;
855         for (i = 0, bp = nu->bp; i < totpoly; i++, bp++, vl = (VertLink *)vl->next) {
856           copy_v3_v3(bp->vec, mvert[vl->index].co);
857           bp->f1 = SELECT;
858           bp->radius = bp->weight = 1.0;
859         }
860         BLI_freelistN(&polyline);
861
862         /* add nurb to curve */
863         BLI_addtail(nurblist, nu);
864       }
865       /* --- done with nurbs --- */
866     }
867   }
868 }
869
870 void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene), Object *ob)
871 {
872   /* make new mesh data from the original copy */
873   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
874   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
875   Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
876   ListBase nurblist = {NULL, NULL};
877
878   BKE_mesh_to_curve_nurblist(me_eval, &nurblist, 0);
879   BKE_mesh_to_curve_nurblist(me_eval, &nurblist, 1);
880
881   if (nurblist.first) {
882     Curve *cu = BKE_curve_add(bmain, ob->id.name + 2, OB_CURVE);
883     cu->flag |= CU_3D;
884
885     cu->nurb = nurblist;
886
887     id_us_min(&((Mesh *)ob->data)->id);
888     ob->data = cu;
889     ob->type = OB_CURVE;
890
891     BKE_object_free_derived_caches(ob);
892   }
893 }
894
895 /* settings: 1 - preview, 2 - render
896  *
897  * The convention goes as following:
898  *
899  * - Passing original object with apply_modifiers=false will give a
900  *   non-modified non-deformed mesh.
901  *   The result mesh will point to datablocks from the original "domain". For
902  *   example, materials will be original.
903  *
904  * - Passing original object with apply_modifiers=true will give a mesh which
905  *   has all modifiers applied.
906  *   The result mesh will point to datablocks from the original "domain". For
907  *   example, materials will be original.
908  *
909  * - Passing evaluated object will ignore apply_modifiers argument, and the
910  *   result always contains all modifiers applied.
911  *   The result mesh will point to an evaluated datablocks. For example,
912  *   materials will be an evaluated IDs from the dependency graph.
913  */
914 Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
915                                Main *bmain,
916                                Scene *sce,
917                                Object *ob,
918                                const bool apply_modifiers,
919                                const bool calc_undeformed)
920 {
921   Mesh *tmpmesh;
922   Curve *tmpcu = NULL, *copycu;
923   int i;
924   const bool render = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
925   bool effective_apply_modifiers = apply_modifiers;
926   bool do_mat_id_data_us = true;
927
928   Object *object_input = ob;
929   Object *object_eval = DEG_get_evaluated_object(depsgraph, object_input);
930   Object object_for_eval;
931
932   if (object_eval == object_input) {
933     /* Evaluated mesh contains all modifiers applied already.
934      * The other types of object has them applied, but are stored in other
935      * data structures than a mesh. So need to apply modifiers again on a
936      * temporary copy before converting result to mesh. */
937     if (object_input->type == OB_MESH) {
938       effective_apply_modifiers = false;
939     }
940     else {
941       effective_apply_modifiers = true;
942     }
943     object_for_eval = *object_eval;
944   }
945   else {
946     if (apply_modifiers) {
947       object_for_eval = *object_eval;
948       if (object_for_eval.runtime.mesh_orig != NULL) {
949         object_for_eval.data = object_for_eval.runtime.mesh_orig;
950       }
951     }
952     else {
953       object_for_eval = *object_input;
954     }
955   }
956
957   const bool cage = !effective_apply_modifiers;
958
959   /* perform the mesh extraction based on type */
960   switch (object_for_eval.type) {
961     case OB_FONT:
962     case OB_CURVE:
963     case OB_SURF: {
964       ListBase dispbase = {NULL, NULL};
965       Mesh *me_eval_final = NULL;
966       int uv_from_orco;
967
968       /* copies object and modifiers (but not the data) */
969       Object *tmpobj;
970       BKE_id_copy_ex(NULL, &object_for_eval.id, (ID **)&tmpobj, LIB_ID_COPY_LOCALIZE);
971       tmpcu = (Curve *)tmpobj->data;
972
973       /* Copy cached display list, it might be needed by the stack evaluation.
974        * Ideally stack should be able to use render-time display list, but doing
975        * so is quite tricky and not safe so close to the release.
976        *
977        * TODO(sergey): Look into more proper solution.
978        */
979       if (object_for_eval.runtime.curve_cache != NULL) {
980         if (tmpobj->runtime.curve_cache == NULL) {
981           tmpobj->runtime.curve_cache = MEM_callocN(sizeof(CurveCache),
982                                                     "CurveCache for curve types");
983         }
984         BKE_displist_copy(&tmpobj->runtime.curve_cache->disp,
985                           &object_for_eval.runtime.curve_cache->disp);
986       }
987
988       /* if getting the original caged mesh, delete object modifiers */
989       if (cage) {
990         BKE_object_free_modifiers(tmpobj, LIB_ID_CREATE_NO_USER_REFCOUNT);
991       }
992
993       /* copies the data, but *not* the shapekeys. */
994       BKE_id_copy_ex(NULL, object_for_eval.data, (ID **)&copycu, LIB_ID_COPY_LOCALIZE);
995       tmpobj->data = copycu;
996
997       /* make sure texture space is calculated for a copy of curve,
998        * it will be used for the final result.
999        */
1000       BKE_curve_texspace_calc(copycu);
1001
1002       /* temporarily set edit so we get updates from edit mode, but
1003        * also because for text datablocks copying it while in edit
1004        * mode gives invalid data structures */
1005       copycu->editfont = tmpcu->editfont;
1006       copycu->editnurb = tmpcu->editnurb;
1007
1008       /* get updated display list, and convert to a mesh */
1009       BKE_displist_make_curveTypes_forRender(
1010           depsgraph, sce, tmpobj, &dispbase, &me_eval_final, false, render, NULL);
1011
1012       copycu->editfont = NULL;
1013       copycu->editnurb = NULL;
1014
1015       tmpobj->runtime.mesh_eval = me_eval_final;
1016
1017       /* convert object type to mesh */
1018       uv_from_orco = (tmpcu->flag & CU_UV_ORCO) != 0;
1019       BKE_mesh_from_nurbs_displist(
1020           bmain, tmpobj, &dispbase, uv_from_orco, tmpcu->id.name + 2, true);
1021       /* Function above also frees copycu (aka tmpobj->data), make this obvious here. */
1022       copycu = NULL;
1023
1024       tmpmesh = tmpobj->data;
1025       id_us_min(
1026           &tmpmesh->id); /* Gets one user from its creation in BKE_mesh_from_nurbs_displist(). */
1027
1028       BKE_displist_free(&dispbase);
1029
1030       /* BKE_mesh_from_nurbs changes the type to a mesh, check it worked.
1031        * if it didn't the curve did not have any segments or otherwise
1032        * would have generated an empty mesh */
1033       if (tmpobj->type != OB_MESH) {
1034         BKE_id_free(NULL, tmpobj);
1035         return NULL;
1036       }
1037
1038       BKE_id_free(NULL, tmpobj);
1039
1040       /* XXX The curve to mesh conversion is convoluted...
1041        *     But essentially, BKE_mesh_from_nurbs_displist()
1042        *     already transfers the ownership of materials from the temp copy of the Curve ID to the
1043        *     new Mesh ID, so we do not want to increase materials' usercount later. */
1044       do_mat_id_data_us = false;
1045
1046       break;
1047     }
1048
1049     case OB_MBALL: {
1050       /* metaballs don't have modifiers, so just convert to mesh */
1051       Object *basis_ob = BKE_mball_basis_find(sce, object_input);
1052       /* todo, re-generatre for render-res */
1053       /* metaball_polygonize(scene, ob) */
1054
1055       if (basis_ob != object_input) {
1056         /* Only do basis metaball. */
1057         return NULL;
1058       }
1059
1060       tmpmesh = BKE_mesh_add(bmain, ((ID *)object_for_eval.data)->name + 2);
1061       /* BKE_mesh_add gives us a user count we don't need */
1062       id_us_min(&tmpmesh->id);
1063
1064       if (render) {
1065         ListBase disp = {NULL, NULL};
1066         BKE_displist_make_mball_forRender(depsgraph, sce, &object_for_eval, &disp);
1067         BKE_mesh_from_metaball(&disp, tmpmesh);
1068         BKE_displist_free(&disp);
1069       }
1070       else {
1071         ListBase disp = {NULL, NULL};
1072         if (object_for_eval.runtime.curve_cache) {
1073           disp = object_for_eval.runtime.curve_cache->disp;
1074         }
1075         BKE_mesh_from_metaball(&disp, tmpmesh);
1076       }
1077
1078       BKE_mesh_texspace_copy_from_object(tmpmesh, &object_for_eval);
1079
1080       break;
1081     }
1082     case OB_MESH:
1083       /* copies object and modifiers (but not the data) */
1084       if (cage) {
1085         /* copies the data (but *not* the shapekeys). */
1086         Mesh *mesh = object_for_eval.data;
1087         BKE_id_copy_ex(bmain, &mesh->id, (ID **)&tmpmesh, 0);
1088         /* XXX BKE_mesh_copy() already handles materials usercount. */
1089         do_mat_id_data_us = false;
1090       }
1091       /* if not getting the original caged mesh, get final derived mesh */
1092       else {
1093         /* Make a dummy mesh, saves copying */
1094         Mesh *me_eval;
1095         CustomData_MeshMasks mask = CD_MASK_MESH; /* this seems more suitable, exporter,
1096                                                    * for example, needs CD_MASK_MDEFORMVERT */
1097
1098         if (calc_undeformed) {
1099           mask.vmask |= CD_MASK_ORCO;
1100         }
1101
1102         if (render) {
1103           me_eval = mesh_create_eval_final_render(depsgraph, sce, &object_for_eval, &mask);
1104         }
1105         else {
1106           me_eval = mesh_create_eval_final_view(depsgraph, sce, &object_for_eval, &mask);
1107         }
1108
1109         tmpmesh = BKE_mesh_add(bmain, ((ID *)object_for_eval.data)->name + 2);
1110         BKE_mesh_nomain_to_mesh(me_eval, tmpmesh, &object_for_eval, &mask, true);
1111
1112         /* Copy autosmooth settings from original mesh. */
1113         Mesh *me = (Mesh *)object_for_eval.data;
1114         tmpmesh->flag |= (me->flag & ME_AUTOSMOOTH);
1115         tmpmesh->smoothresh = me->smoothresh;
1116       }
1117
1118       /* BKE_mesh_add/copy gives us a user count we don't need */
1119       id_us_min(&tmpmesh->id);
1120
1121       break;
1122     default:
1123       /* "Object does not have geometry data") */
1124       return NULL;
1125   }
1126
1127   /* Copy materials to new mesh */
1128   switch (object_for_eval.type) {
1129     case OB_SURF:
1130     case OB_FONT:
1131     case OB_CURVE:
1132       tmpmesh->totcol = tmpcu->totcol;
1133
1134       /* free old material list (if it exists) and adjust user counts */
1135       if (tmpcu->mat) {
1136         for (i = tmpcu->totcol; i-- > 0;) {
1137           /* are we an object material or data based? */
1138           tmpmesh->mat[i] = give_current_material(object_input, i + 1);
1139
1140           if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
1141               tmpmesh->mat[i]) {
1142             id_us_plus(&tmpmesh->mat[i]->id);
1143           }
1144         }
1145       }
1146       break;
1147
1148     case OB_MBALL: {
1149       MetaBall *tmpmb = (MetaBall *)object_for_eval.data;
1150       tmpmesh->mat = MEM_dupallocN(tmpmb->mat);
1151       tmpmesh->totcol = tmpmb->totcol;
1152
1153       /* free old material list (if it exists) and adjust user counts */
1154       if (tmpmb->mat) {
1155         for (i = tmpmb->totcol; i-- > 0;) {
1156           /* are we an object material or data based? */
1157           tmpmesh->mat[i] = give_current_material(object_input, i + 1);
1158
1159           if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
1160               tmpmesh->mat[i]) {
1161             id_us_plus(&tmpmesh->mat[i]->id);
1162           }
1163         }
1164       }
1165       break;
1166     }
1167
1168     case OB_MESH:
1169       if (!cage) {
1170         Mesh *origmesh = object_for_eval.data;
1171         tmpmesh->flag = origmesh->flag;
1172         tmpmesh->mat = MEM_dupallocN(origmesh->mat);
1173         tmpmesh->totcol = origmesh->totcol;
1174         tmpmesh->smoothresh = origmesh->smoothresh;
1175         if (origmesh->mat) {
1176           for (i = origmesh->totcol; i-- > 0;) {
1177             /* are we an object material or data based? */
1178             tmpmesh->mat[i] = give_current_material(object_input, i + 1);
1179
1180             if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
1181                 tmpmesh->mat[i]) {
1182               id_us_plus(&tmpmesh->mat[i]->id);
1183             }
1184           }
1185         }
1186       }
1187       break;
1188   } /* end copy materials */
1189
1190   return tmpmesh;
1191 }
1192
1193 static void add_shapekey_layers(Mesh *mesh_dest, Mesh *mesh_src)
1194 {
1195   KeyBlock *kb;
1196   Key *key = mesh_src->key;
1197   int i;
1198
1199   if (!mesh_src->key) {
1200     return;
1201   }
1202
1203   /* ensure we can use mesh vertex count for derived mesh custom data */
1204   if (mesh_src->totvert != mesh_dest->totvert) {
1205     CLOG_ERROR(&LOG,
1206                "vertex size mismatch (mesh/dm) '%s' (%d != %d)",
1207                mesh_src->id.name + 2,
1208                mesh_src->totvert,
1209                mesh_dest->totvert);
1210     return;
1211   }
1212
1213   for (i = 0, kb = key->block.first; kb; kb = kb->next, i++) {
1214     int ci;
1215     float *array;
1216
1217     if (mesh_src->totvert != kb->totelem) {
1218       CLOG_ERROR(&LOG,
1219                  "vertex size mismatch (Mesh '%s':%d != KeyBlock '%s':%d)",
1220                  mesh_src->id.name + 2,
1221                  mesh_src->totvert,
1222                  kb->name,
1223                  kb->totelem);
1224       array = MEM_calloc_arrayN((size_t)mesh_src->totvert, 3 * sizeof(float), __func__);
1225     }
1226     else {
1227       array = MEM_malloc_arrayN((size_t)mesh_src->totvert, 3 * sizeof(float), __func__);
1228       memcpy(array, kb->data, (size_t)mesh_src->totvert * 3 * sizeof(float));
1229     }
1230
1231     CustomData_add_layer_named(
1232         &mesh_dest->vdata, CD_SHAPEKEY, CD_ASSIGN, array, mesh_dest->totvert, kb->name);
1233     ci = CustomData_get_layer_index_n(&mesh_dest->vdata, CD_SHAPEKEY, i);
1234
1235     mesh_dest->vdata.layers[ci].uid = kb->uid;
1236   }
1237 }
1238
1239 Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
1240                                            Scene *scene,
1241                                            Object *ob_eval,
1242                                            ModifierData *md_eval,
1243                                            int build_shapekey_layers)
1244 {
1245   Mesh *me = ob_eval->runtime.mesh_orig ? ob_eval->runtime.mesh_orig : ob_eval->data;
1246   const ModifierTypeInfo *mti = modifierType_getInfo(md_eval->type);
1247   Mesh *result;
1248   KeyBlock *kb;
1249   ModifierEvalContext mectx = {depsgraph, ob_eval, 0};
1250
1251   if (!(md_eval->mode & eModifierMode_Realtime)) {
1252     return NULL;
1253   }
1254
1255   if (mti->isDisabled && mti->isDisabled(scene, md_eval, 0)) {
1256     return NULL;
1257   }
1258
1259   if (build_shapekey_layers && me->key &&
1260       (kb = BLI_findlink(&me->key->block, ob_eval->shapenr - 1))) {
1261     BKE_keyblock_convert_to_mesh(kb, me);
1262   }
1263
1264   if (mti->type == eModifierTypeType_OnlyDeform) {
1265     int numVerts;
1266     float(*deformedVerts)[3] = BKE_mesh_vertexCos_get(me, &numVerts);
1267
1268     mti->deformVerts(md_eval, &mectx, NULL, deformedVerts, numVerts);
1269     BKE_id_copy_ex(NULL, &me->id, (ID **)&result, LIB_ID_COPY_LOCALIZE);
1270     BKE_mesh_apply_vert_coords(result, deformedVerts);
1271
1272     if (build_shapekey_layers) {
1273       add_shapekey_layers(result, me);
1274     }
1275
1276     MEM_freeN(deformedVerts);
1277   }
1278   else {
1279     Mesh *mesh_temp;
1280     BKE_id_copy_ex(NULL, &me->id, (ID **)&mesh_temp, LIB_ID_COPY_LOCALIZE);
1281
1282     if (build_shapekey_layers) {
1283       add_shapekey_layers(mesh_temp, me);
1284     }
1285
1286     result = mti->applyModifier(md_eval, &mectx, mesh_temp);
1287     ASSERT_IS_VALID_MESH(result);
1288
1289     if (mesh_temp != result) {
1290       BKE_id_free(NULL, mesh_temp);
1291     }
1292   }
1293
1294   return result;
1295 }
1296
1297 /* This is a Mesh-based copy of the same function in DerivedMesh.c */
1298 static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int actshape_uid)
1299 {
1300   KeyBlock *kb;
1301   int i, j, tot;
1302
1303   if (!mesh_dst->key) {
1304     return;
1305   }
1306
1307   tot = CustomData_number_of_layers(&mesh_src->vdata, CD_SHAPEKEY);
1308   for (i = 0; i < tot; i++) {
1309     CustomDataLayer *layer =
1310         &mesh_src->vdata.layers[CustomData_get_layer_index_n(&mesh_src->vdata, CD_SHAPEKEY, i)];
1311     float(*cos)[3], (*kbcos)[3];
1312
1313     for (kb = mesh_dst->key->block.first; kb; kb = kb->next) {
1314       if (kb->uid == layer->uid) {
1315         break;
1316       }
1317     }
1318
1319     if (!kb) {
1320       kb = BKE_keyblock_add(mesh_dst->key, layer->name);
1321       kb->uid = layer->uid;
1322     }
1323
1324     if (kb->data) {
1325       MEM_freeN(kb->data);
1326     }
1327
1328     cos = CustomData_get_layer_n(&mesh_src->vdata, CD_SHAPEKEY, i);
1329     kb->totelem = mesh_src->totvert;
1330
1331     kb->data = kbcos = MEM_malloc_arrayN(kb->totelem, 3 * sizeof(float), __func__);
1332     if (kb->uid == actshape_uid) {
1333       MVert *mvert = mesh_src->mvert;
1334
1335       for (j = 0; j < mesh_src->totvert; j++, kbcos++, mvert++) {
1336         copy_v3_v3(*kbcos, mvert->co);
1337       }
1338     }
1339     else {
1340       for (j = 0; j < kb->totelem; j++, cos++, kbcos++) {
1341         copy_v3_v3(*kbcos, *cos);
1342       }
1343     }
1344   }
1345
1346   for (kb = mesh_dst->key->block.first; kb; kb = kb->next) {
1347     if (kb->totelem != mesh_src->totvert) {
1348       if (kb->data) {
1349         MEM_freeN(kb->data);
1350       }
1351
1352       kb->totelem = mesh_src->totvert;
1353       kb->data = MEM_calloc_arrayN(kb->totelem, 3 * sizeof(float), __func__);
1354       CLOG_ERROR(&LOG, "lost a shapekey layer: '%s'! (bmesh internal error)", kb->name);
1355     }
1356   }
1357 }
1358
1359 /* This is a Mesh-based copy of DM_to_mesh() */
1360 void BKE_mesh_nomain_to_mesh(Mesh *mesh_src,
1361                              Mesh *mesh_dst,
1362                              Object *ob,
1363                              const CustomData_MeshMasks *mask,
1364                              bool take_ownership)
1365 {
1366   /* mesh_src might depend on mesh_dst, so we need to do everything with a local copy */
1367   /* TODO(Sybren): the above claim came from DM_to_mesh();
1368    * check whether it is still true with Mesh */
1369   Mesh tmp = *mesh_dst;
1370   int totvert, totedge /*, totface */ /* UNUSED */, totloop, totpoly;
1371   int did_shapekeys = 0;
1372   eCDAllocType alloctype = CD_DUPLICATE;
1373
1374   if (take_ownership /* && dm->type == DM_TYPE_CDDM && dm->needsFree */) {
1375     bool has_any_referenced_layers = CustomData_has_referenced(&mesh_src->vdata) ||
1376                                      CustomData_has_referenced(&mesh_src->edata) ||
1377                                      CustomData_has_referenced(&mesh_src->ldata) ||
1378                                      CustomData_has_referenced(&mesh_src->fdata) ||
1379                                      CustomData_has_referenced(&mesh_src->pdata);
1380     if (!has_any_referenced_layers) {
1381       alloctype = CD_ASSIGN;
1382     }
1383   }
1384   CustomData_reset(&tmp.vdata);
1385   CustomData_reset(&tmp.edata);
1386   CustomData_reset(&tmp.fdata);
1387   CustomData_reset(&tmp.ldata);
1388   CustomData_reset(&tmp.pdata);
1389
1390   BKE_mesh_ensure_normals(mesh_src);
1391
1392   totvert = tmp.totvert = mesh_src->totvert;
1393   totedge = tmp.totedge = mesh_src->totedge;
1394   totloop = tmp.totloop = mesh_src->totloop;
1395   totpoly = tmp.totpoly = mesh_src->totpoly;
1396   tmp.totface = 0;
1397
1398   CustomData_copy(&mesh_src->vdata, &tmp.vdata, mask->vmask, alloctype, totvert);
1399   CustomData_copy(&mesh_src->edata, &tmp.edata, mask->emask, alloctype, totedge);
1400   CustomData_copy(&mesh_src->ldata, &tmp.ldata, mask->lmask, alloctype, totloop);
1401   CustomData_copy(&mesh_src->pdata, &tmp.pdata, mask->pmask, alloctype, totpoly);
1402   tmp.cd_flag = mesh_src->cd_flag;
1403   tmp.runtime.deformed_only = mesh_src->runtime.deformed_only;
1404
1405   if (CustomData_has_layer(&mesh_src->vdata, CD_SHAPEKEY)) {
1406     KeyBlock *kb;
1407     int uid;
1408
1409     if (ob) {
1410       kb = BLI_findlink(&mesh_dst->key->block, ob->shapenr - 1);
1411       if (kb) {
1412         uid = kb->uid;
1413       }
1414       else {
1415         CLOG_ERROR(&LOG, "could not find active shapekey %d!", ob->shapenr - 1);
1416
1417         uid = INT_MAX;
1418       }
1419     }
1420     else {
1421       /* if no object, set to INT_MAX so we don't mess up any shapekey layers */
1422       uid = INT_MAX;
1423     }
1424
1425     shapekey_layers_to_keyblocks(mesh_src, mesh_dst, uid);
1426     did_shapekeys = 1;
1427   }
1428
1429   /* copy texture space */
1430   if (ob) {
1431     BKE_mesh_texspace_copy_from_object(&tmp, ob);
1432   }
1433
1434   /* not all DerivedMeshes store their verts/edges/faces in CustomData, so
1435    * we set them here in case they are missing */
1436   /* TODO(Sybren): we could probably replace CD_ASSIGN with alloctype and
1437    * always directly pass mesh_src->mxxx, instead of using a ternary operator. */
1438   if (!CustomData_has_layer(&tmp.vdata, CD_MVERT)) {
1439     CustomData_add_layer(&tmp.vdata,
1440                          CD_MVERT,
1441                          CD_ASSIGN,
1442                          (alloctype == CD_ASSIGN) ? mesh_src->mvert :
1443                                                     MEM_dupallocN(mesh_src->mvert),
1444                          totvert);
1445   }
1446   if (!CustomData_has_layer(&tmp.edata, CD_MEDGE)) {
1447     CustomData_add_layer(&tmp.edata,
1448                          CD_MEDGE,
1449                          CD_ASSIGN,
1450                          (alloctype == CD_ASSIGN) ? mesh_src->medge :
1451                                                     MEM_dupallocN(mesh_src->medge),
1452                          totedge);
1453   }
1454   if (!CustomData_has_layer(&tmp.pdata, CD_MPOLY)) {
1455     /* TODO(Sybren): assignment to tmp.mxxx is probably not necessary due to the
1456      * BKE_mesh_update_customdata_pointers() call below. */
1457     tmp.mloop = (alloctype == CD_ASSIGN) ? mesh_src->mloop : MEM_dupallocN(mesh_src->mloop);
1458     tmp.mpoly = (alloctype == CD_ASSIGN) ? mesh_src->mpoly : MEM_dupallocN(mesh_src->mpoly);
1459
1460     CustomData_add_layer(&tmp.ldata, CD_MLOOP, CD_ASSIGN, tmp.mloop, tmp.totloop);
1461     CustomData_add_layer(&tmp.pdata, CD_MPOLY, CD_ASSIGN, tmp.mpoly, tmp.totpoly);
1462   }
1463
1464   /* object had got displacement layer, should copy this layer to save sculpted data */
1465   /* NOTE: maybe some other layers should be copied? nazgul */
1466   if (CustomData_has_layer(&mesh_dst->ldata, CD_MDISPS)) {
1467     if (totloop == mesh_dst->totloop) {
1468       MDisps *mdisps = CustomData_get_layer(&mesh_dst->ldata, CD_MDISPS);
1469       CustomData_add_layer(&tmp.ldata, CD_MDISPS, alloctype, mdisps, totloop);
1470     }
1471   }
1472
1473   /* yes, must be before _and_ after tessellate */
1474   BKE_mesh_update_customdata_pointers(&tmp, false);
1475
1476   /* since 2.65 caller must do! */
1477   // BKE_mesh_tessface_calc(&tmp);
1478
1479   CustomData_free(&mesh_dst->vdata, mesh_dst->totvert);
1480   CustomData_free(&mesh_dst->edata, mesh_dst->totedge);
1481   CustomData_free(&mesh_dst->fdata, mesh_dst->totface);
1482   CustomData_free(&mesh_dst->ldata, mesh_dst->totloop);
1483   CustomData_free(&mesh_dst->pdata, mesh_dst->totpoly);
1484
1485   /* ok, this should now use new CD shapekey data,
1486    * which should be fed through the modifier
1487    * stack */
1488   if (tmp.totvert != mesh_dst->totvert && !did_shapekeys && mesh_dst->key) {
1489     CLOG_ERROR(&LOG, "YEEK! this should be recoded! Shape key loss!: ID '%s'", tmp.id.name);
1490     if (tmp.key && !(tmp.id.tag & LIB_TAG_NO_MAIN)) {
1491       id_us_min(&tmp.key->id);
1492     }
1493     tmp.key = NULL;
1494   }
1495
1496   /* Clear selection history */
1497   MEM_SAFE_FREE(tmp.mselect);
1498   tmp.totselect = 0;
1499   BLI_assert(ELEM(tmp.bb, NULL, mesh_dst->bb));
1500   if (mesh_dst->bb) {
1501     MEM_freeN(mesh_dst->bb);
1502     tmp.bb = NULL;
1503   }
1504
1505   /* skip the listbase */
1506   MEMCPY_STRUCT_AFTER(mesh_dst, &tmp, id.prev);
1507
1508   if (take_ownership) {
1509     if (alloctype == CD_ASSIGN) {
1510       CustomData_free_typemask(&mesh_src->vdata, mesh_src->totvert, ~mask->vmask);
1511       CustomData_free_typemask(&mesh_src->edata, mesh_src->totedge, ~mask->emask);
1512       CustomData_free_typemask(&mesh_src->ldata, mesh_src->totloop, ~mask->lmask);
1513       CustomData_free_typemask(&mesh_src->pdata, mesh_src->totpoly, ~mask->pmask);
1514     }
1515     BKE_id_free(NULL, mesh_src);
1516   }
1517 }
1518
1519 /* This is a Mesh-based copy of DM_to_meshkey() */
1520 void BKE_mesh_nomain_to_meshkey(Mesh *mesh_src, Mesh *mesh_dst, KeyBlock *kb)
1521 {
1522   int a, totvert = mesh_src->totvert;
1523   float *fp;
1524   MVert *mvert;
1525
1526   if (totvert == 0 || mesh_dst->totvert == 0 || mesh_dst->totvert != totvert) {
1527     return;
1528   }
1529
1530   if (kb->data) {
1531     MEM_freeN(kb->data);
1532   }
1533   kb->data = MEM_malloc_arrayN(mesh_dst->key->elemsize, mesh_dst->totvert, "kb->data");
1534   kb->totelem = totvert;
1535
1536   fp = kb->data;
1537   mvert = mesh_src->mvert;
1538
1539   for (a = 0; a < kb->totelem; a++, fp += 3, mvert++) {
1540     copy_v3_v3(fp, mvert->co);
1541   }
1542 }