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