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