Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / DerivedMesh.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  * The Original Code is Copyright (C) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25 #include <limits.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_cloth_types.h"
30 #include "DNA_customdata_types.h"
31 #include "DNA_key_types.h"
32 #include "DNA_material_types.h"
33 #include "DNA_mesh_types.h"
34 #include "DNA_meshdata_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_scene_types.h"
37
38 #include "BLI_array.h"
39 #include "BLI_blenlib.h"
40 #include "BLI_bitmap.h"
41 #include "BLI_math.h"
42 #include "BLI_utildefines.h"
43 #include "BLI_linklist.h"
44 #include "BLI_task.h"
45
46 #include "BKE_cdderivedmesh.h"
47 #include "BKE_colorband.h"
48 #include "BKE_editmesh.h"
49 #include "BKE_key.h"
50 #include "BKE_layer.h"
51 #include "BKE_library.h"
52 #include "BKE_material.h"
53 #include "BKE_modifier.h"
54 #include "BKE_mesh.h"
55 #include "BKE_mesh_iterators.h"
56 #include "BKE_mesh_mapping.h"
57 #include "BKE_mesh_runtime.h"
58 #include "BKE_mesh_tangent.h"
59 #include "BKE_object.h"
60 #include "BKE_object_deform.h"
61 #include "BKE_paint.h"
62 #include "BKE_multires.h"
63 #include "BKE_bvhutils.h"
64 #include "BKE_deform.h"
65
66 #include "BLI_sys_types.h" /* for intptr_t support */
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_query.h"
70 #include "BKE_shrinkwrap.h"
71
72 #include "CLG_log.h"
73
74 #ifdef WITH_OPENSUBDIV
75 #  include "DNA_userdef_types.h"
76 #endif
77
78 /* very slow! enable for testing only! */
79 //#define USE_MODIFIER_VALIDATE
80
81 #ifdef USE_MODIFIER_VALIDATE
82 #  define ASSERT_IS_VALID_DM(dm) (BLI_assert((dm == NULL) || (DM_is_valid(dm) == true)))
83 #  define ASSERT_IS_VALID_MESH(mesh) \
84     (BLI_assert((mesh == NULL) || (BKE_mesh_is_valid(mesh) == true)))
85 #else
86 #  define ASSERT_IS_VALID_DM(dm)
87 #  define ASSERT_IS_VALID_MESH(mesh)
88 #endif
89
90 static CLG_LogRef LOG = {"bke.derivedmesh"};
91 static ThreadRWMutex loops_cache_lock = PTHREAD_RWLOCK_INITIALIZER;
92
93 static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid);
94
95 static void mesh_init_origspace(Mesh *mesh);
96
97 /* -------------------------------------------------------------------- */
98
99 static MVert *dm_getVertArray(DerivedMesh *dm)
100 {
101   MVert *mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
102
103   if (!mvert) {
104     mvert = CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, dm->getNumVerts(dm));
105     CustomData_set_layer_flag(&dm->vertData, CD_MVERT, CD_FLAG_TEMPORARY);
106     dm->copyVertArray(dm, mvert);
107   }
108
109   return mvert;
110 }
111
112 static MEdge *dm_getEdgeArray(DerivedMesh *dm)
113 {
114   MEdge *medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
115
116   if (!medge) {
117     medge = CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, dm->getNumEdges(dm));
118     CustomData_set_layer_flag(&dm->edgeData, CD_MEDGE, CD_FLAG_TEMPORARY);
119     dm->copyEdgeArray(dm, medge);
120   }
121
122   return medge;
123 }
124
125 static MFace *dm_getTessFaceArray(DerivedMesh *dm)
126 {
127   MFace *mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
128
129   if (!mface) {
130     int numTessFaces = dm->getNumTessFaces(dm);
131
132     if (!numTessFaces) {
133       /* Do not add layer if there's no elements in it, this leads to issues later when
134        * this layer is needed with non-zero size, but currently CD stuff does not check
135        * for requested layer size on creation and just returns layer which was previously
136        * added (sergey) */
137       return NULL;
138     }
139
140     mface = CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
141     CustomData_set_layer_flag(&dm->faceData, CD_MFACE, CD_FLAG_TEMPORARY);
142     dm->copyTessFaceArray(dm, mface);
143   }
144
145   return mface;
146 }
147
148 static MLoop *dm_getLoopArray(DerivedMesh *dm)
149 {
150   MLoop *mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
151
152   if (!mloop) {
153     mloop = CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, dm->getNumLoops(dm));
154     CustomData_set_layer_flag(&dm->loopData, CD_MLOOP, CD_FLAG_TEMPORARY);
155     dm->copyLoopArray(dm, mloop);
156   }
157
158   return mloop;
159 }
160
161 static MPoly *dm_getPolyArray(DerivedMesh *dm)
162 {
163   MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
164
165   if (!mpoly) {
166     mpoly = CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, dm->getNumPolys(dm));
167     CustomData_set_layer_flag(&dm->polyData, CD_MPOLY, CD_FLAG_TEMPORARY);
168     dm->copyPolyArray(dm, mpoly);
169   }
170
171   return mpoly;
172 }
173
174 static MVert *dm_dupVertArray(DerivedMesh *dm)
175 {
176   MVert *tmp = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(*tmp), "dm_dupVertArray tmp");
177
178   if (tmp) {
179     dm->copyVertArray(dm, tmp);
180   }
181
182   return tmp;
183 }
184
185 static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
186 {
187   MEdge *tmp = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(*tmp), "dm_dupEdgeArray tmp");
188
189   if (tmp) {
190     dm->copyEdgeArray(dm, tmp);
191   }
192
193   return tmp;
194 }
195
196 static MFace *dm_dupFaceArray(DerivedMesh *dm)
197 {
198   MFace *tmp = MEM_malloc_arrayN(dm->getNumTessFaces(dm), sizeof(*tmp), "dm_dupFaceArray tmp");
199
200   if (tmp) {
201     dm->copyTessFaceArray(dm, tmp);
202   }
203
204   return tmp;
205 }
206
207 static MLoop *dm_dupLoopArray(DerivedMesh *dm)
208 {
209   MLoop *tmp = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(*tmp), "dm_dupLoopArray tmp");
210
211   if (tmp) {
212     dm->copyLoopArray(dm, tmp);
213   }
214
215   return tmp;
216 }
217
218 static MPoly *dm_dupPolyArray(DerivedMesh *dm)
219 {
220   MPoly *tmp = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(*tmp), "dm_dupPolyArray tmp");
221
222   if (tmp) {
223     dm->copyPolyArray(dm, tmp);
224   }
225
226   return tmp;
227 }
228
229 static int dm_getNumLoopTri(DerivedMesh *dm)
230 {
231   const int numlooptris = poly_to_tri_count(dm->getNumPolys(dm), dm->getNumLoops(dm));
232   BLI_assert(ELEM(dm->looptris.num, 0, numlooptris));
233   return numlooptris;
234 }
235
236 static const MLoopTri *dm_getLoopTriArray(DerivedMesh *dm)
237 {
238   MLoopTri *looptri;
239
240   BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_READ);
241   looptri = dm->looptris.array;
242   BLI_rw_mutex_unlock(&loops_cache_lock);
243
244   if (looptri != NULL) {
245     BLI_assert(dm->getNumLoopTri(dm) == dm->looptris.num);
246   }
247   else {
248     BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_WRITE);
249     /* We need to ensure array is still NULL inside mutex-protected code, some other thread might have already
250      * recomputed those looptris. */
251     if (dm->looptris.array == NULL) {
252       dm->recalcLoopTri(dm);
253     }
254     looptri = dm->looptris.array;
255     BLI_rw_mutex_unlock(&loops_cache_lock);
256   }
257   return looptri;
258 }
259
260 static CustomData *dm_getVertCData(DerivedMesh *dm)
261 {
262   return &dm->vertData;
263 }
264
265 static CustomData *dm_getEdgeCData(DerivedMesh *dm)
266 {
267   return &dm->edgeData;
268 }
269
270 static CustomData *dm_getTessFaceCData(DerivedMesh *dm)
271 {
272   return &dm->faceData;
273 }
274
275 static CustomData *dm_getLoopCData(DerivedMesh *dm)
276 {
277   return &dm->loopData;
278 }
279
280 static CustomData *dm_getPolyCData(DerivedMesh *dm)
281 {
282   return &dm->polyData;
283 }
284
285 /**
286  * Utility function to initialize a DerivedMesh's function pointers to
287  * the default implementation (for those functions which have a default)
288  */
289 void DM_init_funcs(DerivedMesh *dm)
290 {
291   /* default function implementations */
292   dm->getVertArray = dm_getVertArray;
293   dm->getEdgeArray = dm_getEdgeArray;
294   dm->getTessFaceArray = dm_getTessFaceArray;
295   dm->getLoopArray = dm_getLoopArray;
296   dm->getPolyArray = dm_getPolyArray;
297   dm->dupVertArray = dm_dupVertArray;
298   dm->dupEdgeArray = dm_dupEdgeArray;
299   dm->dupTessFaceArray = dm_dupFaceArray;
300   dm->dupLoopArray = dm_dupLoopArray;
301   dm->dupPolyArray = dm_dupPolyArray;
302
303   dm->getLoopTriArray = dm_getLoopTriArray;
304
305   /* subtypes handle getting actual data */
306   dm->getNumLoopTri = dm_getNumLoopTri;
307
308   dm->getVertDataLayout = dm_getVertCData;
309   dm->getEdgeDataLayout = dm_getEdgeCData;
310   dm->getTessFaceDataLayout = dm_getTessFaceCData;
311   dm->getLoopDataLayout = dm_getLoopCData;
312   dm->getPolyDataLayout = dm_getPolyCData;
313
314   dm->getVertData = DM_get_vert_data;
315   dm->getEdgeData = DM_get_edge_data;
316   dm->getTessFaceData = DM_get_tessface_data;
317   dm->getPolyData = DM_get_poly_data;
318   dm->getVertDataArray = DM_get_vert_data_layer;
319   dm->getEdgeDataArray = DM_get_edge_data_layer;
320   dm->getTessFaceDataArray = DM_get_tessface_data_layer;
321   dm->getPolyDataArray = DM_get_poly_data_layer;
322   dm->getLoopDataArray = DM_get_loop_data_layer;
323
324   dm->bvhCache = NULL;
325 }
326
327 /**
328  * Utility function to initialize a DerivedMesh for the desired number
329  * of vertices, edges and faces (doesn't allocate memory for them, just
330  * sets up the custom data layers)
331  */
332 void DM_init(DerivedMesh *dm,
333              DerivedMeshType type,
334              int numVerts,
335              int numEdges,
336              int numTessFaces,
337              int numLoops,
338              int numPolys)
339 {
340   dm->type = type;
341   dm->numVertData = numVerts;
342   dm->numEdgeData = numEdges;
343   dm->numTessFaceData = numTessFaces;
344   dm->numLoopData = numLoops;
345   dm->numPolyData = numPolys;
346
347   DM_init_funcs(dm);
348
349   dm->needsFree = 1;
350   dm->dirty = 0;
351
352   /* don't use CustomData_reset(...); because we dont want to touch customdata */
353   copy_vn_i(dm->vertData.typemap, CD_NUMTYPES, -1);
354   copy_vn_i(dm->edgeData.typemap, CD_NUMTYPES, -1);
355   copy_vn_i(dm->faceData.typemap, CD_NUMTYPES, -1);
356   copy_vn_i(dm->loopData.typemap, CD_NUMTYPES, -1);
357   copy_vn_i(dm->polyData.typemap, CD_NUMTYPES, -1);
358 }
359
360 /**
361  * Utility function to initialize a DerivedMesh for the desired number
362  * of vertices, edges and faces, with a layer setup copied from source
363  */
364 void DM_from_template_ex(DerivedMesh *dm,
365                          DerivedMesh *source,
366                          DerivedMeshType type,
367                          int numVerts,
368                          int numEdges,
369                          int numTessFaces,
370                          int numLoops,
371                          int numPolys,
372                          const CustomData_MeshMasks *mask)
373 {
374   CustomData_copy(&source->vertData, &dm->vertData, mask->vmask, CD_CALLOC, numVerts);
375   CustomData_copy(&source->edgeData, &dm->edgeData, mask->emask, CD_CALLOC, numEdges);
376   CustomData_copy(&source->faceData, &dm->faceData, mask->fmask, CD_CALLOC, numTessFaces);
377   CustomData_copy(&source->loopData, &dm->loopData, mask->lmask, CD_CALLOC, numLoops);
378   CustomData_copy(&source->polyData, &dm->polyData, mask->pmask, CD_CALLOC, numPolys);
379
380   dm->cd_flag = source->cd_flag;
381
382   dm->type = type;
383   dm->numVertData = numVerts;
384   dm->numEdgeData = numEdges;
385   dm->numTessFaceData = numTessFaces;
386   dm->numLoopData = numLoops;
387   dm->numPolyData = numPolys;
388
389   DM_init_funcs(dm);
390
391   dm->needsFree = 1;
392   dm->dirty = 0;
393 }
394 void DM_from_template(DerivedMesh *dm,
395                       DerivedMesh *source,
396                       DerivedMeshType type,
397                       int numVerts,
398                       int numEdges,
399                       int numTessFaces,
400                       int numLoops,
401                       int numPolys)
402 {
403   DM_from_template_ex(dm,
404                       source,
405                       type,
406                       numVerts,
407                       numEdges,
408                       numTessFaces,
409                       numLoops,
410                       numPolys,
411                       &CD_MASK_DERIVEDMESH);
412 }
413
414 int DM_release(DerivedMesh *dm)
415 {
416   if (dm->needsFree) {
417     bvhcache_free(&dm->bvhCache);
418     CustomData_free(&dm->vertData, dm->numVertData);
419     CustomData_free(&dm->edgeData, dm->numEdgeData);
420     CustomData_free(&dm->faceData, dm->numTessFaceData);
421     CustomData_free(&dm->loopData, dm->numLoopData);
422     CustomData_free(&dm->polyData, dm->numPolyData);
423
424     if (dm->mat) {
425       MEM_freeN(dm->mat);
426       dm->mat = NULL;
427       dm->totmat = 0;
428     }
429
430     MEM_SAFE_FREE(dm->looptris.array);
431     dm->looptris.num = 0;
432     dm->looptris.num_alloc = 0;
433
434     return 1;
435   }
436   else {
437     CustomData_free_temporary(&dm->vertData, dm->numVertData);
438     CustomData_free_temporary(&dm->edgeData, dm->numEdgeData);
439     CustomData_free_temporary(&dm->faceData, dm->numTessFaceData);
440     CustomData_free_temporary(&dm->loopData, dm->numLoopData);
441     CustomData_free_temporary(&dm->polyData, dm->numPolyData);
442
443     return 0;
444   }
445 }
446
447 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target)
448 {
449   CustomData_free(&target->loopData, source->numLoopData);
450   CustomData_free(&target->polyData, source->numPolyData);
451
452   CustomData_copy(&source->loopData,
453                   &target->loopData,
454                   CD_MASK_DERIVEDMESH.lmask,
455                   CD_DUPLICATE,
456                   source->numLoopData);
457   CustomData_copy(&source->polyData,
458                   &target->polyData,
459                   CD_MASK_DERIVEDMESH.pmask,
460                   CD_DUPLICATE,
461                   source->numPolyData);
462
463   target->numLoopData = source->numLoopData;
464   target->numPolyData = source->numPolyData;
465
466   if (!CustomData_has_layer(&target->polyData, CD_MPOLY)) {
467     MPoly *mpoly;
468     MLoop *mloop;
469
470     mloop = source->dupLoopArray(source);
471     mpoly = source->dupPolyArray(source);
472     CustomData_add_layer(&target->loopData, CD_MLOOP, CD_ASSIGN, mloop, source->numLoopData);
473     CustomData_add_layer(&target->polyData, CD_MPOLY, CD_ASSIGN, mpoly, source->numPolyData);
474   }
475 }
476
477 void DM_ensure_normals(DerivedMesh *dm)
478 {
479   if (dm->dirty & DM_DIRTY_NORMALS) {
480     dm->calcNormals(dm);
481   }
482   BLI_assert((dm->dirty & DM_DIRTY_NORMALS) == 0);
483 }
484
485 /**
486  * Ensure the array is large enough
487  *
488  * \note This function must always be thread-protected by caller. It should only be used by internal code.
489  */
490 void DM_ensure_looptri_data(DerivedMesh *dm)
491 {
492   const unsigned int totpoly = dm->numPolyData;
493   const unsigned int totloop = dm->numLoopData;
494   const int looptris_num = poly_to_tri_count(totpoly, totloop);
495
496   BLI_assert(dm->looptris.array_wip == NULL);
497
498   SWAP(MLoopTri *, dm->looptris.array, dm->looptris.array_wip);
499
500   if ((looptris_num > dm->looptris.num_alloc) || (looptris_num < dm->looptris.num_alloc * 2) ||
501       (totpoly == 0)) {
502     MEM_SAFE_FREE(dm->looptris.array_wip);
503     dm->looptris.num_alloc = 0;
504     dm->looptris.num = 0;
505   }
506
507   if (totpoly) {
508     if (dm->looptris.array_wip == NULL) {
509       dm->looptris.array_wip = MEM_malloc_arrayN(
510           looptris_num, sizeof(*dm->looptris.array_wip), __func__);
511       dm->looptris.num_alloc = looptris_num;
512     }
513
514     dm->looptris.num = looptris_num;
515   }
516 }
517
518 void DM_to_mesh(
519     DerivedMesh *dm, Mesh *me, Object *ob, const CustomData_MeshMasks *mask, bool take_ownership)
520 {
521   /* dm might depend on me, so we need to do everything with a local copy */
522   Mesh tmp = *me;
523   int totvert, totedge /*, totface */ /* UNUSED */, totloop, totpoly;
524   int did_shapekeys = 0;
525   eCDAllocType alloctype = CD_DUPLICATE;
526
527   if (take_ownership && dm->type == DM_TYPE_CDDM && dm->needsFree) {
528     bool has_any_referenced_layers = CustomData_has_referenced(&dm->vertData) ||
529                                      CustomData_has_referenced(&dm->edgeData) ||
530                                      CustomData_has_referenced(&dm->loopData) ||
531                                      CustomData_has_referenced(&dm->faceData) ||
532                                      CustomData_has_referenced(&dm->polyData);
533     if (!has_any_referenced_layers) {
534       alloctype = CD_ASSIGN;
535     }
536   }
537
538   CustomData_reset(&tmp.vdata);
539   CustomData_reset(&tmp.edata);
540   CustomData_reset(&tmp.fdata);
541   CustomData_reset(&tmp.ldata);
542   CustomData_reset(&tmp.pdata);
543
544   DM_ensure_normals(dm);
545
546   totvert = tmp.totvert = dm->getNumVerts(dm);
547   totedge = tmp.totedge = dm->getNumEdges(dm);
548   totloop = tmp.totloop = dm->getNumLoops(dm);
549   totpoly = tmp.totpoly = dm->getNumPolys(dm);
550   tmp.totface = 0;
551
552   CustomData_copy(&dm->vertData, &tmp.vdata, mask->vmask, alloctype, totvert);
553   CustomData_copy(&dm->edgeData, &tmp.edata, mask->emask, alloctype, totedge);
554   CustomData_copy(&dm->loopData, &tmp.ldata, mask->lmask, alloctype, totloop);
555   CustomData_copy(&dm->polyData, &tmp.pdata, mask->pmask, alloctype, totpoly);
556   tmp.cd_flag = dm->cd_flag;
557   tmp.runtime.deformed_only = dm->deformedOnly;
558
559   if (CustomData_has_layer(&dm->vertData, CD_SHAPEKEY)) {
560     KeyBlock *kb;
561     int uid;
562
563     if (ob) {
564       kb = BLI_findlink(&me->key->block, ob->shapenr - 1);
565       if (kb) {
566         uid = kb->uid;
567       }
568       else {
569         CLOG_ERROR(&LOG, "could not find active shapekey %d!", ob->shapenr - 1);
570         uid = INT_MAX;
571       }
572     }
573     else {
574       /* if no object, set to INT_MAX so we don't mess up any shapekey layers */
575       uid = INT_MAX;
576     }
577
578     shapekey_layers_to_keyblocks(dm, me, uid);
579     did_shapekeys = 1;
580   }
581
582   /* copy texture space */
583   if (ob) {
584     BKE_mesh_texspace_copy_from_object(&tmp, ob);
585   }
586
587   /* not all DerivedMeshes store their verts/edges/faces in CustomData, so
588    * we set them here in case they are missing */
589   if (!CustomData_has_layer(&tmp.vdata, CD_MVERT)) {
590     CustomData_add_layer(&tmp.vdata,
591                          CD_MVERT,
592                          CD_ASSIGN,
593                          (alloctype == CD_ASSIGN) ? dm->getVertArray(dm) : dm->dupVertArray(dm),
594                          totvert);
595   }
596   if (!CustomData_has_layer(&tmp.edata, CD_MEDGE)) {
597     CustomData_add_layer(&tmp.edata,
598                          CD_MEDGE,
599                          CD_ASSIGN,
600                          (alloctype == CD_ASSIGN) ? dm->getEdgeArray(dm) : dm->dupEdgeArray(dm),
601                          totedge);
602   }
603   if (!CustomData_has_layer(&tmp.pdata, CD_MPOLY)) {
604     tmp.mloop = (alloctype == CD_ASSIGN) ? dm->getLoopArray(dm) : dm->dupLoopArray(dm);
605     tmp.mpoly = (alloctype == CD_ASSIGN) ? dm->getPolyArray(dm) : dm->dupPolyArray(dm);
606
607     CustomData_add_layer(&tmp.ldata, CD_MLOOP, CD_ASSIGN, tmp.mloop, tmp.totloop);
608     CustomData_add_layer(&tmp.pdata, CD_MPOLY, CD_ASSIGN, tmp.mpoly, tmp.totpoly);
609   }
610
611   /* object had got displacement layer, should copy this layer to save sculpted data */
612   /* NOTE: maybe some other layers should be copied? nazgul */
613   if (CustomData_has_layer(&me->ldata, CD_MDISPS)) {
614     if (totloop == me->totloop) {
615       MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS);
616       CustomData_add_layer(&tmp.ldata, CD_MDISPS, alloctype, mdisps, totloop);
617     }
618   }
619
620   /* yes, must be before _and_ after tessellate */
621   BKE_mesh_update_customdata_pointers(&tmp, false);
622
623   /* since 2.65 caller must do! */
624   // BKE_mesh_tessface_calc(&tmp);
625
626   CustomData_free(&me->vdata, me->totvert);
627   CustomData_free(&me->edata, me->totedge);
628   CustomData_free(&me->fdata, me->totface);
629   CustomData_free(&me->ldata, me->totloop);
630   CustomData_free(&me->pdata, me->totpoly);
631
632   /* ok, this should now use new CD shapekey data,
633    * which should be fed through the modifier
634    * stack */
635   if (tmp.totvert != me->totvert && !did_shapekeys && me->key) {
636     CLOG_WARN(&LOG, "YEEK! this should be recoded! Shape key loss!: ID '%s'", tmp.id.name);
637     if (tmp.key && !(tmp.id.tag & LIB_TAG_NO_MAIN)) {
638       id_us_min(&tmp.key->id);
639     }
640     tmp.key = NULL;
641   }
642
643   /* Clear selection history */
644   MEM_SAFE_FREE(tmp.mselect);
645   tmp.totselect = 0;
646   BLI_assert(ELEM(tmp.bb, NULL, me->bb));
647   if (me->bb) {
648     MEM_freeN(me->bb);
649     tmp.bb = NULL;
650   }
651
652   /* skip the listbase */
653   MEMCPY_STRUCT_AFTER(me, &tmp, id.prev);
654
655   if (take_ownership) {
656     if (alloctype == CD_ASSIGN) {
657       CustomData_free_typemask(&dm->vertData, dm->numVertData, ~mask->vmask);
658       CustomData_free_typemask(&dm->edgeData, dm->numEdgeData, ~mask->emask);
659       CustomData_free_typemask(&dm->loopData, dm->numLoopData, ~mask->lmask);
660       CustomData_free_typemask(&dm->polyData, dm->numPolyData, ~mask->pmask);
661     }
662     dm->release(dm);
663   }
664 }
665
666 /** Utility function to convert an (evaluated) Mesh to a shape key block. */
667 /* Just a shallow wrapper around BKE_keyblock_convert_from_mesh,
668  * that ensures both evaluated mesh and original one has same number of vertices. */
669 void BKE_mesh_runtime_eval_to_meshkey(Mesh *me_deformed, Mesh *me, KeyBlock *kb)
670 {
671   const int totvert = me_deformed->totvert;
672
673   if (totvert == 0 || me->totvert == 0 || me->totvert != totvert) {
674     return;
675   }
676
677   BKE_keyblock_convert_from_mesh(me_deformed, me->key, kb);
678 }
679
680 /**
681  * set the CD_FLAG_NOCOPY flag in custom data layers where the mask is
682  * zero for the layer type, so only layer types specified by the mask
683  * will be copied
684  */
685 void DM_set_only_copy(DerivedMesh *dm, const CustomData_MeshMasks *mask)
686 {
687   CustomData_set_only_copy(&dm->vertData, mask->vmask);
688   CustomData_set_only_copy(&dm->edgeData, mask->emask);
689   CustomData_set_only_copy(&dm->faceData, mask->fmask);
690   /* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
691    * weight paint mode when there are modifiers applied, needs further investigation,
692    * see replies to r50969, Campbell */
693 #if 0
694   CustomData_set_only_copy(&dm->loopData, mask->lmask);
695   CustomData_set_only_copy(&dm->polyData, mask->pmask);
696 #endif
697 }
698
699 static void mesh_set_only_copy(Mesh *mesh, const CustomData_MeshMasks *mask)
700 {
701   CustomData_set_only_copy(&mesh->vdata, mask->vmask);
702   CustomData_set_only_copy(&mesh->edata, mask->emask);
703   CustomData_set_only_copy(&mesh->fdata, mask->fmask);
704   /* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
705    * weight paint mode when there are modifiers applied, needs further investigation,
706    * see replies to r50969, Campbell */
707 #if 0
708   CustomData_set_only_copy(&mesh->ldata, mask->lmask);
709   CustomData_set_only_copy(&mesh->pdata, mask->pmask);
710 #endif
711 }
712
713 void DM_add_vert_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
714 {
715   CustomData_add_layer(&dm->vertData, type, alloctype, layer, dm->numVertData);
716 }
717
718 void DM_add_edge_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
719 {
720   CustomData_add_layer(&dm->edgeData, type, alloctype, layer, dm->numEdgeData);
721 }
722
723 void DM_add_tessface_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
724 {
725   CustomData_add_layer(&dm->faceData, type, alloctype, layer, dm->numTessFaceData);
726 }
727
728 void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
729 {
730   CustomData_add_layer(&dm->loopData, type, alloctype, layer, dm->numLoopData);
731 }
732
733 void DM_add_poly_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
734 {
735   CustomData_add_layer(&dm->polyData, type, alloctype, layer, dm->numPolyData);
736 }
737
738 void *DM_get_vert_data(DerivedMesh *dm, int index, int type)
739 {
740   BLI_assert(index >= 0 && index < dm->getNumVerts(dm));
741   return CustomData_get(&dm->vertData, index, type);
742 }
743
744 void *DM_get_edge_data(DerivedMesh *dm, int index, int type)
745 {
746   BLI_assert(index >= 0 && index < dm->getNumEdges(dm));
747   return CustomData_get(&dm->edgeData, index, type);
748 }
749
750 void *DM_get_tessface_data(DerivedMesh *dm, int index, int type)
751 {
752   BLI_assert(index >= 0 && index < dm->getNumTessFaces(dm));
753   return CustomData_get(&dm->faceData, index, type);
754 }
755
756 void *DM_get_poly_data(DerivedMesh *dm, int index, int type)
757 {
758   BLI_assert(index >= 0 && index < dm->getNumPolys(dm));
759   return CustomData_get(&dm->polyData, index, type);
760 }
761
762 void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
763 {
764   if (type == CD_MVERT) {
765     return dm->getVertArray(dm);
766   }
767
768   return CustomData_get_layer(&dm->vertData, type);
769 }
770
771 void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
772 {
773   if (type == CD_MEDGE) {
774     return dm->getEdgeArray(dm);
775   }
776
777   return CustomData_get_layer(&dm->edgeData, type);
778 }
779
780 void *DM_get_tessface_data_layer(DerivedMesh *dm, int type)
781 {
782   if (type == CD_MFACE) {
783     return dm->getTessFaceArray(dm);
784   }
785
786   return CustomData_get_layer(&dm->faceData, type);
787 }
788
789 void *DM_get_poly_data_layer(DerivedMesh *dm, int type)
790 {
791   return CustomData_get_layer(&dm->polyData, type);
792 }
793
794 void *DM_get_loop_data_layer(DerivedMesh *dm, int type)
795 {
796   return CustomData_get_layer(&dm->loopData, type);
797 }
798
799 void DM_copy_vert_data(
800     DerivedMesh *source, DerivedMesh *dest, int source_index, int dest_index, int count)
801 {
802   CustomData_copy_data(&source->vertData, &dest->vertData, source_index, dest_index, count);
803 }
804
805 /**
806  * interpolates vertex data from the vertices indexed by src_indices in the
807  * source mesh using the given weights and stores the result in the vertex
808  * indexed by dest_index in the dest mesh
809  */
810 void DM_interp_vert_data(DerivedMesh *source,
811                          DerivedMesh *dest,
812                          int *src_indices,
813                          float *weights,
814                          int count,
815                          int dest_index)
816 {
817   CustomData_interp(
818       &source->vertData, &dest->vertData, src_indices, weights, NULL, count, dest_index);
819 }
820
821 DerivedMesh *mesh_create_derived(Mesh *me, float (*vertCos)[3])
822 {
823   DerivedMesh *dm = CDDM_from_mesh(me);
824
825   if (!dm) {
826     return NULL;
827   }
828
829   if (vertCos) {
830     CDDM_apply_vert_coords(dm, vertCos);
831   }
832
833   return dm;
834 }
835
836 static float (*get_editbmesh_orco_verts(BMEditMesh *em))[3]
837 {
838   BMIter iter;
839   BMVert *eve;
840   float(*orco)[3];
841   int i;
842
843   /* these may not really be the orco's, but it's only for preview.
844    * could be solver better once, but isn't simple */
845
846   orco = MEM_malloc_arrayN(em->bm->totvert, sizeof(float) * 3, "BMEditMesh Orco");
847
848   BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
849     copy_v3_v3(orco[i], eve->co);
850   }
851
852   return orco;
853 }
854
855 /* orco custom data layer */
856 static float (*get_orco_coords(Object *ob, BMEditMesh *em, int layer, int *free))[3]
857 {
858   *free = 0;
859
860   if (layer == CD_ORCO) {
861     /* get original coordinates */
862     *free = 1;
863
864     if (em) {
865       return get_editbmesh_orco_verts(em);
866     }
867     else {
868       return BKE_mesh_orco_verts_get(ob);
869     }
870   }
871   else if (layer == CD_CLOTH_ORCO) {
872     /* apply shape key for cloth, this should really be solved
873      * by a more flexible customdata system, but not simple */
874     if (!em) {
875       ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
876       KeyBlock *kb = BKE_keyblock_from_key(BKE_key_from_object(ob),
877                                            clmd->sim_parms->shapekey_rest);
878
879       if (kb && kb->data) {
880         return kb->data;
881       }
882     }
883
884     return NULL;
885   }
886
887   return NULL;
888 }
889
890 static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
891 {
892   Mesh *mesh;
893   float(*orco)[3];
894   int free;
895
896   if (em) {
897     mesh = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, NULL);
898   }
899   else {
900     mesh = BKE_mesh_copy_for_eval(me, true);
901   }
902
903   orco = get_orco_coords(ob, em, layer, &free);
904
905   if (orco) {
906     BKE_mesh_apply_vert_coords(mesh, orco);
907     if (free) {
908       MEM_freeN(orco);
909     }
910   }
911
912   return mesh;
913 }
914
915 static void add_orco_mesh(Object *ob, BMEditMesh *em, Mesh *mesh, Mesh *mesh_orco, int layer)
916 {
917   float(*orco)[3], (*layerorco)[3];
918   int totvert, free;
919
920   totvert = mesh->totvert;
921
922   if (mesh_orco) {
923     free = 1;
924
925     if (mesh_orco->totvert == totvert) {
926       orco = BKE_mesh_vertexCos_get(mesh_orco, NULL);
927     }
928     else {
929       orco = BKE_mesh_vertexCos_get(mesh, NULL);
930     }
931   }
932   else {
933     /* TODO(sybren): totvert should potentially change here, as ob->data
934      * or em may have a different number of vertices than dm. */
935     orco = get_orco_coords(ob, em, layer, &free);
936   }
937
938   if (orco) {
939     if (layer == CD_ORCO) {
940       BKE_mesh_orco_verts_transform(ob->data, orco, totvert, 0);
941     }
942
943     if (!(layerorco = CustomData_get_layer(&mesh->vdata, layer))) {
944       CustomData_add_layer(&mesh->vdata, layer, CD_CALLOC, NULL, mesh->totvert);
945       BKE_mesh_update_customdata_pointers(mesh, false);
946
947       layerorco = CustomData_get_layer(&mesh->vdata, layer);
948     }
949
950     memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
951     if (free) {
952       MEM_freeN(orco);
953     }
954   }
955 }
956
957 static void editmesh_update_statvis_color(const Scene *scene, Object *ob)
958 {
959   BMEditMesh *em = BKE_editmesh_from_object(ob);
960   Mesh *me = ob->data;
961   BKE_mesh_runtime_ensure_edit_data(me);
962   BKE_editmesh_statvis_calc(em, me->runtime.edit_data, &scene->toolsettings->statvis);
963 }
964
965 static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid)
966 {
967   KeyBlock *kb;
968   int i, j, tot;
969
970   if (!me->key) {
971     return;
972   }
973
974   tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
975   for (i = 0; i < tot; i++) {
976     CustomDataLayer *layer =
977         &dm->vertData.layers[CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i)];
978     float(*cos)[3], (*kbcos)[3];
979
980     for (kb = me->key->block.first; kb; kb = kb->next) {
981       if (kb->uid == layer->uid) {
982         break;
983       }
984     }
985
986     if (!kb) {
987       kb = BKE_keyblock_add(me->key, layer->name);
988       kb->uid = layer->uid;
989     }
990
991     if (kb->data) {
992       MEM_freeN(kb->data);
993     }
994
995     cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
996     kb->totelem = dm->numVertData;
997
998     kb->data = kbcos = MEM_malloc_arrayN(kb->totelem, 3 * sizeof(float), "kbcos DerivedMesh.c");
999     if (kb->uid == actshape_uid) {
1000       MVert *mvert = dm->getVertArray(dm);
1001
1002       for (j = 0; j < dm->numVertData; j++, kbcos++, mvert++) {
1003         copy_v3_v3(*kbcos, mvert->co);
1004       }
1005     }
1006     else {
1007       for (j = 0; j < kb->totelem; j++, cos++, kbcos++) {
1008         copy_v3_v3(*kbcos, *cos);
1009       }
1010     }
1011   }
1012
1013   for (kb = me->key->block.first; kb; kb = kb->next) {
1014     if (kb->totelem != dm->numVertData) {
1015       if (kb->data) {
1016         MEM_freeN(kb->data);
1017       }
1018
1019       kb->totelem = dm->numVertData;
1020       kb->data = MEM_calloc_arrayN(kb->totelem, 3 * sizeof(float), "kb->data derivedmesh.c");
1021       CLOG_ERROR(&LOG, "lost a shapekey layer: '%s'! (bmesh internal error)", kb->name);
1022     }
1023   }
1024 }
1025
1026 static void mesh_copy_autosmooth(Mesh *me, Mesh *me_orig)
1027 {
1028   if (me_orig->flag & ME_AUTOSMOOTH) {
1029     me->flag |= ME_AUTOSMOOTH;
1030     me->smoothresh = me_orig->smoothresh;
1031   }
1032 }
1033
1034 static void mesh_calc_modifier_final_normals(const Mesh *mesh_input,
1035                                              const CustomData_MeshMasks *dataMask,
1036                                              const bool sculpt_dyntopo,
1037                                              Mesh *mesh_final)
1038 {
1039   /* Compute normals. */
1040   const bool do_loop_normals = ((mesh_input->flag & ME_AUTOSMOOTH) != 0 ||
1041                                 (dataMask->lmask & CD_MASK_NORMAL) != 0);
1042   /* Some modifiers may need this info from their target (other) object, simpler to generate it here as well.
1043    * Note that they will always be generated when no loop normals are comptuted,
1044    * since they are needed by drawing code. */
1045   const bool do_poly_normals = ((dataMask->pmask & CD_MASK_NORMAL) != 0);
1046
1047   if (do_loop_normals) {
1048     /* In case we also need poly normals, add the layer here, then BKE_mesh_calc_normals_split() will fill it. */
1049     if (do_poly_normals) {
1050       if (!CustomData_has_layer(&mesh_final->pdata, CD_NORMAL)) {
1051         CustomData_add_layer(&mesh_final->pdata, CD_NORMAL, CD_CALLOC, NULL, mesh_final->totpoly);
1052       }
1053     }
1054     /* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
1055     BKE_mesh_calc_normals_split(mesh_final);
1056     BKE_mesh_tessface_clear(mesh_final);
1057   }
1058
1059   if (sculpt_dyntopo == false) {
1060     /* watch this! after 2.75a we move to from tessface to looptri (by default) */
1061     if (dataMask->fmask & CD_MASK_MFACE) {
1062       BKE_mesh_tessface_ensure(mesh_final);
1063     }
1064
1065     /* without this, drawing ngon tri's faces will show ugly tessellated face
1066      * normals and will also have to calculate normals on the fly, try avoid
1067      * this where possible since calculating polygon normals isn't fast,
1068      * note that this isn't a problem for subsurf (only quads) or editmode
1069      * which deals with drawing differently.
1070      *
1071      * Only calc vertex normals if they are flagged as dirty.
1072      * If using loop normals, poly nors have already been computed.
1073      */
1074     if (!do_loop_normals) {
1075       BKE_mesh_ensure_normals_for_display(mesh_final);
1076     }
1077   }
1078
1079   /* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
1080    * as they are used by display code when available (i.e. even if autosmooth is disabled). */
1081   if (!do_loop_normals && CustomData_has_layer(&mesh_final->ldata, CD_NORMAL)) {
1082     CustomData_free_layers(&mesh_final->ldata, CD_NORMAL, mesh_final->totloop);
1083   }
1084 }
1085
1086 static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
1087                                 Scene *scene,
1088                                 Object *ob,
1089                                 int useDeform,
1090                                 const bool need_mapping,
1091                                 const CustomData_MeshMasks *dataMask,
1092                                 const int index,
1093                                 const bool use_cache,
1094                                 /* return args */
1095                                 Mesh **r_deform,
1096                                 Mesh **r_final)
1097 {
1098   /* Input and final mesh. Final mesh is only created the moment the first
1099    * constructive modifier is executed, or a deform modifier needs normals
1100    * or certain data layers. */
1101   Mesh *mesh_input = ob->data;
1102   Mesh *mesh_final = NULL;
1103   Mesh *mesh_deform = NULL;
1104   BLI_assert((mesh_input->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
1105
1106   /* Deformed vertex locations array. Deform only modifier need this type of
1107    * float array rather than MVert*. Tracked along with mesh_final as an
1108    * optimization to avoid copying coordinates back and forth if there are
1109    * multiple sequential deform only modifiers. */
1110   float(*deformed_verts)[3] = NULL;
1111   int num_deformed_verts = mesh_input->totvert;
1112   bool isPrevDeform = false;
1113
1114   /* Mesh with constructive modifiers but no deformation applied. Tracked
1115    * along with final mesh if undeformed / orco coordinates are requested
1116    * for texturing. */
1117   Mesh *mesh_orco = NULL;
1118   Mesh *mesh_orco_cloth = NULL;
1119
1120   /* Modifier evaluation modes. */
1121   const bool use_render = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
1122   const int required_mode = use_render ? eModifierMode_Render : eModifierMode_Realtime;
1123
1124   /* Sculpt can skip certain modifiers. */
1125   MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
1126   const bool has_multires = (mmd && mmd->sculptlvl != 0);
1127   bool multires_applied = false;
1128   const bool sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt && !use_render;
1129   const bool sculpt_dyntopo = (sculpt_mode && ob->sculpt->bm) && !use_render;
1130
1131   /* Modifier evaluation contexts for different types of modifiers. */
1132   ModifierApplyFlag app_render = use_render ? MOD_APPLY_RENDER : 0;
1133   ModifierApplyFlag app_cache = use_cache ? MOD_APPLY_USECACHE : 0;
1134   const ModifierEvalContext mectx = {depsgraph, ob, app_render | app_cache};
1135   const ModifierEvalContext mectx_orco = {depsgraph, ob, app_render | MOD_APPLY_ORCO};
1136
1137   /* Get effective list of modifiers to execute. Some effects like shape keys
1138    * are added as virtual modifiers before the user created modifiers. */
1139   VirtualModifierData virtualModifierData;
1140   ModifierData *firstmd = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1141   ModifierData *md = firstmd;
1142
1143   /* Preview colors by modifiers such as dynamic paint, to show the results
1144    * even if the resulting data is not used in a material. Only in object mode.
1145    * TODO: this is broken, not drawn by the drawn manager. */
1146   const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
1147   ModifierData *previewmd = NULL;
1148   CustomData_MeshMasks previewmask = {0};
1149   if (do_mod_mcol) {
1150     /* Find the last active modifier generating a preview, or NULL if none. */
1151     /* XXX Currently, DPaint modifier just ignores this.
1152      *     Needs a stupid hack...
1153      *     The whole "modifier preview" thing has to be (re?)designed, anyway! */
1154     previewmd = modifiers_getLastPreview(scene, md, required_mode);
1155   }
1156
1157   /* Compute accumulated datamasks needed by each modifier. It helps to do
1158    * this fine grained so that for example vertex groups are preserved up to
1159    * an armature modifier, but not through a following subsurf modifier where
1160    * subdividing them is expensive. */
1161   CDMaskLink *datamasks = modifiers_calcDataMasks(
1162       scene, ob, md, dataMask, required_mode, previewmd, &previewmask);
1163   CDMaskLink *md_datamask = datamasks;
1164   /* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
1165   CustomData_MeshMasks append_mask = CD_MASK_BAREMESH_ORIGINDEX;
1166
1167   /* Clear errors before evaluation. */
1168   modifiers_clearErrors(ob);
1169
1170   /* Apply all leading deform modifiers. */
1171   if (useDeform) {
1172     for (; md; md = md->next, md_datamask = md_datamask->next) {
1173       const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1174
1175       if (!modifier_isEnabled(scene, md, required_mode)) {
1176         continue;
1177       }
1178
1179       if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1180         continue;
1181       }
1182
1183       if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
1184         if (!deformed_verts) {
1185           deformed_verts = BKE_mesh_vertexCos_get(mesh_input, &num_deformed_verts);
1186         }
1187         else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1188           if (mesh_final == NULL) {
1189             mesh_final = BKE_mesh_copy_for_eval(mesh_input, true);
1190             ASSERT_IS_VALID_MESH(mesh_final);
1191           }
1192           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1193         }
1194
1195         modwrap_deformVerts(md, &mectx, mesh_final, deformed_verts, num_deformed_verts);
1196
1197         isPrevDeform = true;
1198       }
1199       else {
1200         break;
1201       }
1202
1203       /* grab modifiers until index i */
1204       if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index)) {
1205         break;
1206       }
1207     }
1208
1209     /* Result of all leading deforming modifiers is cached for
1210      * places that wish to use the original mesh but with deformed
1211      * coordinates (like vertex paint). */
1212     if (r_deform) {
1213       mesh_deform = BKE_mesh_copy_for_eval(mesh_input, true);
1214
1215       if (deformed_verts) {
1216         BKE_mesh_apply_vert_coords(mesh_deform, deformed_verts);
1217       }
1218     }
1219   }
1220
1221   /* Apply all remaining constructive and deforming modifiers. */
1222   for (; md; md = md->next, md_datamask = md_datamask->next) {
1223     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1224
1225     if (!modifier_isEnabled(scene, md, required_mode)) {
1226       continue;
1227     }
1228
1229     if (mti->type == eModifierTypeType_OnlyDeform && !useDeform) {
1230       continue;
1231     }
1232
1233     if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && mesh_final) {
1234       modifier_setError(md, "Modifier requires original data, bad stack position");
1235       continue;
1236     }
1237
1238     if (sculpt_mode && (!has_multires || multires_applied || sculpt_dyntopo)) {
1239       bool unsupported = false;
1240
1241       if (md->type == eModifierType_Multires && ((MultiresModifierData *)md)->sculptlvl == 0) {
1242         /* If multires is on level 0 skip it silently without warning message. */
1243         if (!sculpt_dyntopo) {
1244           continue;
1245         }
1246       }
1247
1248       if (sculpt_dyntopo) {
1249         unsupported = true;
1250       }
1251
1252       if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM) {
1253         unsupported |= (mti->type != eModifierTypeType_OnlyDeform);
1254       }
1255
1256       unsupported |= multires_applied;
1257
1258       if (unsupported) {
1259         if (sculpt_dyntopo) {
1260           modifier_setError(md, "Not supported in dyntopo");
1261         }
1262         else {
1263           modifier_setError(md, "Not supported in sculpt mode");
1264         }
1265         continue;
1266       }
1267       else {
1268         modifier_setError(md, "Hide, Mask and optimized display disabled");
1269       }
1270     }
1271
1272     if (need_mapping && !modifier_supportsMapping(md)) {
1273       continue;
1274     }
1275
1276     if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1277       continue;
1278     }
1279
1280     /* Add an orco layer if needed by this modifier. */
1281     if (mesh_final && mti->requiredDataMask) {
1282       CustomData_MeshMasks mask = {0};
1283       mti->requiredDataMask(ob, md, &mask);
1284       if (mask.vmask & CD_MASK_ORCO) {
1285         add_orco_mesh(ob, NULL, mesh_final, mesh_orco, CD_ORCO);
1286       }
1287     }
1288
1289     /* How to apply modifier depends on (a) what we already have as
1290      * a result of previous modifiers (could be a Mesh or just
1291      * deformed vertices) and (b) what type the modifier is. */
1292     if (mti->type == eModifierTypeType_OnlyDeform) {
1293       /* No existing verts to deform, need to build them. */
1294       if (!deformed_verts) {
1295         if (mesh_final) {
1296           /* Deforming a mesh, read the vertex locations
1297            * out of the mesh and deform them. Once done with this
1298            * run of deformers verts will be written back. */
1299           deformed_verts = BKE_mesh_vertexCos_get(mesh_final, &num_deformed_verts);
1300         }
1301         else {
1302           deformed_verts = BKE_mesh_vertexCos_get(mesh_input, &num_deformed_verts);
1303         }
1304       }
1305       /* if this is not the last modifier in the stack then recalculate the normals
1306        * to avoid giving bogus normals to the next modifier see: [#23673] */
1307       else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1308         /* XXX, this covers bug #23673, but we may need normal calc for other types */
1309         if (mesh_final) {
1310           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1311         }
1312       }
1313
1314       modwrap_deformVerts(md, &mectx, mesh_final, deformed_verts, num_deformed_verts);
1315     }
1316     else {
1317       /* determine which data layers are needed by following modifiers */
1318       CustomData_MeshMasks nextmask;
1319       if (md_datamask->next) {
1320         nextmask = md_datamask->next->mask;
1321       }
1322       else {
1323         nextmask = *dataMask;
1324       }
1325
1326       /* apply vertex coordinates or build a Mesh as necessary */
1327       if (mesh_final) {
1328         if (deformed_verts) {
1329           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1330         }
1331       }
1332       else {
1333         mesh_final = BKE_mesh_copy_for_eval(mesh_input, true);
1334         ASSERT_IS_VALID_MESH(mesh_final);
1335
1336         if (deformed_verts) {
1337           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1338         }
1339
1340         /* Initialize original indices the first time we evaluate a
1341          * constructive modifier. Modifiers will then do mapping mostly
1342          * automatic by copying them through CustomData_copy_data along
1343          * with other data.
1344          *
1345          * These are created when either requested by evaluation, or if
1346          * following modifiers requested them. */
1347         if (need_mapping ||
1348             ((nextmask.vmask | nextmask.emask | nextmask.pmask) & CD_MASK_ORIGINDEX)) {
1349           /* calc */
1350           CustomData_add_layer(
1351               &mesh_final->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh_final->totvert);
1352           CustomData_add_layer(
1353               &mesh_final->edata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh_final->totedge);
1354           CustomData_add_layer(
1355               &mesh_final->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh_final->totpoly);
1356
1357           /* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
1358           range_vn_i(
1359               CustomData_get_layer(&mesh_final->vdata, CD_ORIGINDEX), mesh_final->totvert, 0);
1360           range_vn_i(
1361               CustomData_get_layer(&mesh_final->edata, CD_ORIGINDEX), mesh_final->totedge, 0);
1362           range_vn_i(
1363               CustomData_get_layer(&mesh_final->pdata, CD_ORIGINDEX), mesh_final->totpoly, 0);
1364         }
1365       }
1366
1367       /* set the Mesh to only copy needed data */
1368       CustomData_MeshMasks mask = md_datamask->mask;
1369       /* needMapping check here fixes bug [#28112], otherwise it's
1370        * possible that it won't be copied */
1371       CustomData_MeshMasks_update(&mask, &append_mask);
1372       if (need_mapping) {
1373         mask.vmask |= CD_MASK_ORIGINDEX;
1374         mask.emask |= CD_MASK_ORIGINDEX;
1375         mask.pmask |= CD_MASK_ORIGINDEX;
1376       }
1377       mesh_set_only_copy(mesh_final, &mask);
1378
1379       /* add cloth rest shape key if needed */
1380       if (mask.vmask & CD_MASK_CLOTH_ORCO) {
1381         add_orco_mesh(ob, NULL, mesh_final, mesh_orco, CD_CLOTH_ORCO);
1382       }
1383
1384       /* add an origspace layer if needed */
1385       if ((md_datamask->mask.lmask) & CD_MASK_ORIGSPACE_MLOOP) {
1386         if (!CustomData_has_layer(&mesh_final->ldata, CD_ORIGSPACE_MLOOP)) {
1387           CustomData_add_layer(
1388               &mesh_final->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh_final->totloop);
1389           mesh_init_origspace(mesh_final);
1390         }
1391       }
1392
1393       Mesh *mesh_next = modwrap_applyModifier(md, &mectx, mesh_final);
1394       ASSERT_IS_VALID_MESH(mesh_next);
1395
1396       if (mesh_next) {
1397         /* if the modifier returned a new mesh, release the old one */
1398         if (mesh_final != mesh_next) {
1399           BLI_assert(mesh_final != mesh_input);
1400           BKE_id_free(NULL, mesh_final);
1401         }
1402         mesh_final = mesh_next;
1403
1404         if (deformed_verts) {
1405           MEM_freeN(deformed_verts);
1406           deformed_verts = NULL;
1407         }
1408
1409         mesh_copy_autosmooth(mesh_final, mesh_input);
1410       }
1411
1412       /* create an orco mesh in parallel */
1413       if (nextmask.vmask & CD_MASK_ORCO) {
1414         if (!mesh_orco) {
1415           mesh_orco = create_orco_mesh(ob, mesh_input, NULL, CD_ORCO);
1416         }
1417
1418         nextmask.vmask &= ~CD_MASK_ORCO;
1419         CustomData_MeshMasks temp_cddata_masks = {
1420             .vmask = CD_MASK_ORIGINDEX,
1421             .emask = CD_MASK_ORIGINDEX,
1422             .fmask = CD_MASK_ORIGINDEX,
1423             .pmask = CD_MASK_ORIGINDEX,
1424         };
1425         if (mti->requiredDataMask != NULL) {
1426           mti->requiredDataMask(ob, md, &temp_cddata_masks);
1427         }
1428         CustomData_MeshMasks_update(&temp_cddata_masks, &nextmask);
1429         mesh_set_only_copy(mesh_orco, &temp_cddata_masks);
1430
1431         mesh_next = modwrap_applyModifier(md, &mectx_orco, mesh_orco);
1432         ASSERT_IS_VALID_MESH(mesh_next);
1433
1434         if (mesh_next) {
1435           /* if the modifier returned a new mesh, release the old one */
1436           if (mesh_orco != mesh_next) {
1437             BLI_assert(mesh_orco != mesh_input);
1438             BKE_id_free(NULL, mesh_orco);
1439           }
1440
1441           mesh_orco = mesh_next;
1442         }
1443       }
1444
1445       /* create cloth orco mesh in parallel */
1446       if (nextmask.vmask & CD_MASK_CLOTH_ORCO) {
1447         if (!mesh_orco_cloth) {
1448           mesh_orco_cloth = create_orco_mesh(ob, mesh_input, NULL, CD_CLOTH_ORCO);
1449         }
1450
1451         nextmask.vmask &= ~CD_MASK_CLOTH_ORCO;
1452         nextmask.vmask |= CD_MASK_ORIGINDEX;
1453         nextmask.emask |= CD_MASK_ORIGINDEX;
1454         nextmask.pmask |= CD_MASK_ORIGINDEX;
1455         mesh_set_only_copy(mesh_orco_cloth, &nextmask);
1456
1457         mesh_next = modwrap_applyModifier(md, &mectx_orco, mesh_orco_cloth);
1458         ASSERT_IS_VALID_MESH(mesh_next);
1459
1460         if (mesh_next) {
1461           /* if the modifier returned a new mesh, release the old one */
1462           if (mesh_orco_cloth != mesh_next) {
1463             BLI_assert(mesh_orco != mesh_input);
1464             BKE_id_free(NULL, mesh_orco_cloth);
1465           }
1466
1467           mesh_orco_cloth = mesh_next;
1468         }
1469       }
1470
1471       /* in case of dynamic paint, make sure preview mask remains for following modifiers */
1472       /* XXX Temp and hackish solution! */
1473       if (md->type == eModifierType_DynamicPaint) {
1474         append_mask.lmask |= CD_MASK_PREVIEW_MLOOPCOL;
1475       }
1476
1477       mesh_final->runtime.deformed_only = false;
1478     }
1479
1480     isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
1481
1482     /* grab modifiers until index i */
1483     if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index)) {
1484       break;
1485     }
1486
1487     if (sculpt_mode && md->type == eModifierType_Multires) {
1488       multires_applied = true;
1489     }
1490   }
1491
1492   BLI_linklist_free((LinkNode *)datamasks, NULL);
1493
1494   for (md = firstmd; md; md = md->next) {
1495     modifier_freeTemporaryData(md);
1496   }
1497
1498   /* Yay, we are done. If we have a Mesh and deformed vertices
1499    * need to apply these back onto the Mesh. If we have no
1500    * Mesh then we need to build one. */
1501   if (mesh_final == NULL) {
1502     mesh_final = BKE_mesh_copy_for_eval(mesh_input, true);
1503   }
1504   if (deformed_verts) {
1505     BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1506     MEM_freeN(deformed_verts);
1507     deformed_verts = NULL;
1508   }
1509
1510   /* Add orco coordinates to final and deformed mesh if requested. */
1511   if (dataMask->vmask & CD_MASK_ORCO) {
1512     add_orco_mesh(ob, NULL, mesh_final, mesh_orco, CD_ORCO);
1513
1514     if (mesh_deform) {
1515       add_orco_mesh(ob, NULL, mesh_deform, NULL, CD_ORCO);
1516     }
1517   }
1518
1519   if (mesh_orco) {
1520     BKE_id_free(NULL, mesh_orco);
1521   }
1522   if (mesh_orco_cloth) {
1523     BKE_id_free(NULL, mesh_orco_cloth);
1524   }
1525
1526   /* Compute normals. */
1527   mesh_calc_modifier_final_normals(mesh_input, dataMask, sculpt_dyntopo, mesh_final);
1528
1529   /* Return final mesh */
1530   *r_final = mesh_final;
1531   if (r_deform) {
1532     *r_deform = mesh_deform;
1533   }
1534 }
1535
1536 float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
1537 {
1538   BMIter iter;
1539   BMVert *eve;
1540   float(*cos)[3];
1541   int i;
1542
1543   *r_numVerts = em->bm->totvert;
1544
1545   cos = MEM_malloc_arrayN(em->bm->totvert, 3 * sizeof(float), "vertexcos");
1546
1547   BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
1548     copy_v3_v3(cos[i], eve->co);
1549   }
1550
1551   return cos;
1552 }
1553
1554 bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev_mesh)
1555 {
1556   const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1557   const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1558
1559   if (!modifier_isEnabled(scene, md, required_mode)) {
1560     return false;
1561   }
1562
1563   if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && has_prev_mesh) {
1564     modifier_setError(md, "Modifier requires original data, bad stack position");
1565     return false;
1566   }
1567
1568   return true;
1569 }
1570
1571 static void editbmesh_calc_modifier_final_normals(const Mesh *mesh_input,
1572                                                   const CustomData_MeshMasks *dataMask,
1573                                                   Mesh *mesh_final)
1574 {
1575   const bool do_loop_normals = ((mesh_input->flag & ME_AUTOSMOOTH) != 0 ||
1576                                 (dataMask->lmask & CD_MASK_NORMAL) != 0);
1577   /* Some modifiers may need this info from their target (other) object, simpler to generate it here as well. */
1578   const bool do_poly_normals = ((dataMask->pmask & CD_MASK_NORMAL) != 0);
1579
1580   if (do_loop_normals) {
1581     /* In case we also need poly normals, add the layer here, then BKE_mesh_calc_normals_split() will fill it. */
1582     if (do_poly_normals) {
1583       if (!CustomData_has_layer(&mesh_final->pdata, CD_NORMAL)) {
1584         CustomData_add_layer(&mesh_final->pdata, CD_NORMAL, CD_CALLOC, NULL, mesh_final->totpoly);
1585       }
1586     }
1587     /* Compute loop normals */
1588     BKE_mesh_calc_normals_split(mesh_final);
1589     BKE_mesh_tessface_clear(mesh_final);
1590   }
1591
1592   /* BMESH_ONLY, ensure tessface's used for drawing,
1593    * but don't recalculate if the last modifier in the stack gives us tessfaces
1594    * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
1595    * but quiets annoying error messages since tessfaces wont be created. */
1596   if (dataMask->fmask & CD_MASK_MFACE) {
1597     if (mesh_final->edit_mesh == NULL) {
1598       BKE_mesh_tessface_ensure(mesh_final);
1599     }
1600   }
1601
1602   /* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
1603   if (!do_loop_normals) {
1604     BKE_mesh_ensure_normals_for_display(mesh_final);
1605
1606     /* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
1607      * as they are used by display code when available (i.e. even if autosmooth is disabled). */
1608     if (CustomData_has_layer(&mesh_final->ldata, CD_NORMAL)) {
1609       CustomData_free_layers(&mesh_final->ldata, CD_NORMAL, mesh_final->totloop);
1610     }
1611   }
1612 }
1613
1614 static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
1615                                      Scene *scene,
1616                                      Object *ob,
1617                                      BMEditMesh *em_input,
1618                                      const CustomData_MeshMasks *dataMask,
1619                                      /* return args */
1620                                      Mesh **r_cage,
1621                                      Mesh **r_final)
1622 {
1623   /* Input and final mesh. Final mesh is only created the moment the first
1624    * constructive modifier is executed, or a deform modifier needs normals
1625    * or certain data layers. */
1626   Mesh *mesh_input = ob->data;
1627   Mesh *mesh_final = NULL;
1628   Mesh *mesh_cage = NULL;
1629
1630   /* Deformed vertex locations array. Deform only modifier need this type of
1631    * float array rather than MVert*. Tracked along with mesh_final as an
1632    * optimization to avoid copying coordinates back and forth if there are
1633    * multiple sequential deform only modifiers. */
1634   float(*deformed_verts)[3] = NULL;
1635   int num_deformed_verts = 0;
1636   bool isPrevDeform = false;
1637
1638   /* Mesh with constructive modifiers but no deformation applied. Tracked
1639    * along with final mesh if undeformed / orco coordinates are requested
1640    * for texturing. */
1641   Mesh *mesh_orco = NULL;
1642
1643   /* Modifier evaluation modes. */
1644   const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1645   const bool do_init_statvis = false; /* FIXME: use V3D_OVERLAY_EDIT_STATVIS. */
1646
1647   /* Modifier evaluation contexts for different types of modifiers. */
1648   const ModifierEvalContext mectx = {depsgraph, ob, MOD_APPLY_USECACHE};
1649   const ModifierEvalContext mectx_orco = {depsgraph, ob, MOD_APPLY_ORCO};
1650
1651   /* Evaluate modifiers up to certain index to get the mesh cage. */
1652   int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
1653   if (r_cage && cageIndex == -1) {
1654     mesh_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(em_input, dataMask, NULL);
1655     mesh_copy_autosmooth(mesh_cage, mesh_input);
1656   }
1657
1658   /* Get effective list of modifiers to execute. Some effects like shape keys
1659    * are added as virtual modifiers before the user created modifiers. */
1660   VirtualModifierData virtualModifierData;
1661   ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1662
1663   /* Compute accumulated datamasks needed by each modifier. It helps to do
1664    * this fine grained so that for example vertex groups are preserved up to
1665    * an armature modifier, but not through a following subsurf modifier where
1666    * subdividing them is expensive. */
1667   CDMaskLink *datamasks = modifiers_calcDataMasks(
1668       scene, ob, md, dataMask, required_mode, NULL, NULL);
1669   CDMaskLink *md_datamask = datamasks;
1670   CustomData_MeshMasks append_mask = CD_MASK_BAREMESH;
1671
1672   /* Clear errors before evaluation. */
1673   modifiers_clearErrors(ob);
1674
1675   for (int i = 0; md; i++, md = md->next, md_datamask = md_datamask->next) {
1676     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1677
1678     if (!editbmesh_modifier_is_enabled(scene, md, mesh_final != NULL)) {
1679       continue;
1680     }
1681
1682     /* Add an orco layer if needed by this modifier. */
1683     if (mesh_final && mti->requiredDataMask) {
1684       CustomData_MeshMasks mask = {0};
1685       mti->requiredDataMask(ob, md, &mask);
1686       if (mask.vmask & CD_MASK_ORCO) {
1687         add_orco_mesh(ob, em_input, mesh_final, mesh_orco, CD_ORCO);
1688       }
1689     }
1690
1691     /* How to apply modifier depends on (a) what we already have as
1692      * a result of previous modifiers (could be a mesh or just
1693      * deformed vertices) and (b) what type the modifier is. */
1694     if (mti->type == eModifierTypeType_OnlyDeform) {
1695       /* No existing verts to deform, need to build them. */
1696       if (!deformed_verts) {
1697         if (mesh_final) {
1698           /* Deforming a derived mesh, read the vertex locations
1699            * out of the mesh and deform them. Once done with this
1700            * run of deformers verts will be written back. */
1701           deformed_verts = BKE_mesh_vertexCos_get(mesh_final, &num_deformed_verts);
1702         }
1703         else {
1704           deformed_verts = editbmesh_get_vertex_cos(em_input, &num_deformed_verts);
1705         }
1706       }
1707       else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1708         if (mesh_final == NULL) {
1709           mesh_final = BKE_mesh_from_bmesh_for_eval_nomain(em_input->bm, NULL);
1710           ASSERT_IS_VALID_MESH(mesh_final);
1711           mesh_copy_autosmooth(mesh_final, mesh_input);
1712         }
1713         BLI_assert(deformed_verts != NULL);
1714         BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1715       }
1716
1717       if (mti->deformVertsEM) {
1718         modwrap_deformVertsEM(
1719             md, &mectx, em_input, mesh_final, deformed_verts, num_deformed_verts);
1720       }
1721       else {
1722         modwrap_deformVerts(md, &mectx, mesh_final, deformed_verts, num_deformed_verts);
1723       }
1724     }
1725     else {
1726       /* apply vertex coordinates or build a DerivedMesh as necessary */
1727       if (mesh_final) {
1728         if (deformed_verts) {
1729           Mesh *mesh_tmp = BKE_mesh_copy_for_eval(mesh_final, false);
1730           if (mesh_final != mesh_cage) {
1731             BKE_id_free(NULL, mesh_final);
1732           }
1733           mesh_final = mesh_tmp;
1734           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1735         }
1736         else if (mesh_final == mesh_cage) {
1737           /* 'me' may be changed by this modifier, so we need to copy it. */
1738           mesh_final = BKE_mesh_copy_for_eval(mesh_final, false);
1739         }
1740       }
1741       else {
1742         mesh_final = BKE_mesh_from_bmesh_for_eval_nomain(em_input->bm, NULL);
1743         ASSERT_IS_VALID_MESH(mesh_final);
1744
1745         mesh_copy_autosmooth(mesh_final, mesh_input);
1746
1747         if (deformed_verts) {
1748           BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1749         }
1750       }
1751
1752       /* create an orco derivedmesh in parallel */
1753       CustomData_MeshMasks mask = md_datamask->mask;
1754       if (mask.vmask & CD_MASK_ORCO) {
1755         if (!mesh_orco) {
1756           mesh_orco = create_orco_mesh(ob, mesh_input, em_input, CD_ORCO);
1757         }
1758
1759         mask.vmask &= ~CD_MASK_ORCO;
1760         mask.vmask |= CD_MASK_ORIGINDEX;
1761         mask.emask |= CD_MASK_ORIGINDEX;
1762         mask.pmask |= CD_MASK_ORIGINDEX;
1763         mesh_set_only_copy(mesh_orco, &mask);
1764
1765         Mesh *mesh_next = modwrap_applyModifier(md, &mectx_orco, mesh_orco);
1766         ASSERT_IS_VALID_MESH(mesh_next);
1767
1768         if (mesh_next) {
1769           /* if the modifier returned a new dm, release the old one */
1770           if (mesh_orco && mesh_orco != mesh_next) {
1771             BKE_id_free(NULL, mesh_orco);
1772           }
1773           mesh_orco = mesh_next;
1774         }
1775       }
1776
1777       /* set the DerivedMesh to only copy needed data */
1778       CustomData_MeshMasks_update(&mask, &append_mask);
1779       /* XXX WHAT? ovewrites mask ??? */
1780       /* CD_MASK_ORCO may have been cleared above */
1781       mask = md_datamask->mask;
1782       mask.vmask |= CD_MASK_ORIGINDEX;
1783       mask.emask |= CD_MASK_ORIGINDEX;
1784       mask.pmask |= CD_MASK_ORIGINDEX;
1785
1786       mesh_set_only_copy(mesh_final, &mask);
1787
1788       if (mask.lmask & CD_MASK_ORIGSPACE_MLOOP) {
1789         if (!CustomData_has_layer(&mesh_final->ldata, CD_ORIGSPACE_MLOOP)) {
1790           CustomData_add_layer(
1791               &mesh_final->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh_final->totloop);
1792           mesh_init_origspace(mesh_final);
1793         }
1794       }
1795
1796       Mesh *mesh_next = modwrap_applyModifier(md, &mectx, mesh_final);
1797       ASSERT_IS_VALID_MESH(mesh_next);
1798
1799       if (mesh_next) {
1800         if (mesh_final && mesh_final != mesh_next) {
1801           BKE_id_free(NULL, mesh_final);
1802         }
1803         mesh_final = mesh_next;
1804
1805         if (deformed_verts) {
1806           MEM_freeN(deformed_verts);
1807           deformed_verts = NULL;
1808         }
1809
1810         mesh_copy_autosmooth(mesh_final, mesh_input);
1811       }
1812       mesh_final->runtime.deformed_only = false;
1813     }
1814
1815     if (r_cage && i == cageIndex) {
1816       if (mesh_final && deformed_verts) {
1817         mesh_cage = BKE_mesh_copy_for_eval(mesh_final, false);
1818         BKE_mesh_apply_vert_coords(mesh_cage, deformed_verts);
1819       }
1820       else if (mesh_final) {
1821         mesh_cage = mesh_final;
1822       }
1823       else {
1824         Mesh *me_orig = mesh_input;
1825         if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
1826           BKE_mesh_runtime_ensure_edit_data(me_orig);
1827           me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformed_verts);
1828         }
1829         mesh_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(
1830             em_input, dataMask, deformed_verts ? MEM_dupallocN(deformed_verts) : NULL);
1831         mesh_copy_autosmooth(mesh_cage, mesh_input);
1832       }
1833     }
1834
1835     isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
1836   }
1837
1838   BLI_linklist_free((LinkNode *)datamasks, NULL);
1839
1840   /* Yay, we are done. If we have a DerivedMesh and deformed vertices need
1841    * to apply these back onto the DerivedMesh. If we have no DerivedMesh
1842    * then we need to build one. */
1843   if (mesh_final) {
1844     if (deformed_verts) {
1845       Mesh *mesh_tmp = BKE_mesh_copy_for_eval(mesh_final, false);
1846       if (mesh_final != mesh_cage) {
1847         BKE_id_free(NULL, mesh_final);
1848       }
1849       mesh_final = mesh_tmp;
1850       BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
1851     }
1852   }
1853   else if (!deformed_verts && mesh_cage) {
1854     /* cage should already have up to date normals */
1855     mesh_final = mesh_cage;
1856
1857     /* In this case, we should never have weight-modifying modifiers in stack... */
1858     if (do_init_statvis) {
1859       editmesh_update_statvis_color(scene, ob);
1860     }
1861   }
1862   else {
1863     /* this is just a copy of the editmesh, no need to calc normals */
1864     mesh_final = BKE_mesh_from_editmesh_with_coords_thin_wrap(em_input, dataMask, deformed_verts);
1865     deformed_verts = NULL;
1866
1867     mesh_copy_autosmooth(mesh_final, mesh_input);
1868
1869     /* In this case, we should never have weight-modifying modifiers in stack... */
1870     if (do_init_statvis) {
1871       editmesh_update_statvis_color(scene, ob);
1872     }
1873   }
1874
1875   if (deformed_verts) {
1876     MEM_freeN(deformed_verts);
1877   }
1878
1879   /* Add orco coordinates to final and deformed mesh if requested. */
1880   if (dataMask->vmask & CD_MASK_ORCO) {
1881     add_orco_mesh(ob, em_input, mesh_final, mesh_orco, CD_ORCO);
1882   }
1883
1884   if (mesh_orco) {
1885     BKE_id_free(NULL, mesh_orco);
1886   }
1887
1888   /* Compute normals. */
1889   editbmesh_calc_modifier_final_normals(mesh_input, dataMask, mesh_final);
1890   if (mesh_cage && (mesh_cage != mesh_final)) {
1891     editbmesh_calc_modifier_final_normals(mesh_input, dataMask, mesh_cage);
1892   }
1893
1894   /* Return final mesh. */
1895   *r_final = mesh_final;
1896   if (r_cage) {
1897     *r_cage = mesh_cage;
1898   }
1899 }
1900
1901 static void mesh_finalize_eval(Object *object)
1902 {
1903   Mesh *mesh = (Mesh *)object->data;
1904   Mesh *mesh_eval = object->runtime.mesh_eval;
1905   /* Special Tweaks for cases when evaluated mesh came from
1906    * BKE_mesh_new_nomain_from_template().
1907    */
1908   BLI_strncpy(mesh_eval->id.name, mesh->id.name, sizeof(mesh_eval->id.name));
1909   if (mesh_eval->mat != NULL) {
1910     MEM_freeN(mesh_eval->mat);
1911   }
1912   /* Set flag which makes it easier to see what's going on in a debugger. */
1913   mesh_eval->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT;
1914   mesh_eval->mat = MEM_dupallocN(mesh->mat);
1915   mesh_eval->totcol = mesh->totcol;
1916   /* Make evaluated mesh to share same edit mesh pointer as original
1917    * and copied meshes.
1918    */
1919   mesh_eval->edit_mesh = mesh->edit_mesh;
1920   /* Copy autosmooth settings from original mesh.
1921    * This is not done by BKE_mesh_new_nomain_from_template(), so need to take
1922    * extra care here.
1923    */
1924   mesh_eval->flag |= (mesh->flag & ME_AUTOSMOOTH);
1925   mesh_eval->smoothresh = mesh->smoothresh;
1926   /* Replace evaluated object's data with fully evaluated mesh. */
1927   /* TODO(sergey): There was statement done by Sybren and Mai that this
1928    * caused modifiers to be applied twice. which is weirtd and shouldn't
1929    * really happen. But since there is no reference to the report, can not
1930    * do much about this.
1931    */
1932
1933   /* Object is sometimes not evaluated!
1934    * TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
1935   if (object->id.tag & LIB_TAG_COPIED_ON_WRITE) {
1936     object->data = mesh_eval;
1937   }
1938   else {
1939     /* evaluated will be available via: 'object->runtime.mesh_eval' */
1940   }
1941 }
1942
1943 static void mesh_build_extra_data(struct Depsgraph *depsgraph, Object *ob)
1944 {
1945   uint32_t eval_flags = DEG_get_eval_flags_for_id(depsgraph, &ob->id);
1946
1947   if (eval_flags & DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY) {
1948     BKE_shrinkwrap_compute_boundary_data(ob->runtime.mesh_eval);
1949   }
1950 }
1951
1952 static void mesh_runtime_check_normals_valid(const Mesh *mesh)
1953 {
1954   UNUSED_VARS_NDEBUG(mesh);
1955   BLI_assert(!(mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL));
1956   BLI_assert(!(mesh->runtime.cd_dirty_loop & CD_MASK_NORMAL));
1957   BLI_assert(!(mesh->runtime.cd_dirty_poly & CD_MASK_NORMAL));
1958 }
1959
1960 static void mesh_build_data(struct Depsgraph *depsgraph,
1961                             Scene *scene,
1962                             Object *ob,
1963                             const CustomData_MeshMasks *dataMask,
1964                             const bool need_mapping)
1965 {
1966   BLI_assert(ob->type == OB_MESH);
1967
1968   /* Evaluated meshes aren't supposed to be created on original instances. If you do,
1969    * they aren't cleaned up properly on mode switch, causing crashes, e.g T58150. */
1970   BLI_assert(ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
1971
1972   BKE_object_free_derived_caches(ob);
1973   BKE_object_sculpt_modifiers_changed(ob);
1974
1975 #if 0 /* XXX This is already taken care of in mesh_calc_modifiers()... */
1976   if (need_mapping) {
1977     /* Also add the flag so that it is recorded in lastDataMask. */
1978     dataMask->vmask |= CD_MASK_ORIGINDEX;
1979     dataMask->emask |= CD_MASK_ORIGINDEX;
1980     dataMask->pmask |= CD_MASK_ORIGINDEX;
1981   }
1982 #endif
1983
1984   mesh_calc_modifiers(depsgraph,
1985                       scene,
1986                       ob,
1987                       1,
1988                       need_mapping,
1989                       dataMask,
1990                       -1,
1991                       true,
1992                       &ob->runtime.mesh_deform_eval,
1993                       &ob->runtime.mesh_eval);
1994
1995   BKE_object_boundbox_calc_from_mesh(ob, ob->runtime.mesh_eval);
1996   /* Only copy texspace from orig mesh if some modifier (hint: smoke sim, see T58492)
1997    * did not re-enable that flag (which always get disabled for eval mesh as a start). */
1998   if (!(ob->runtime.mesh_eval->texflag & ME_AUTOSPACE)) {
1999     BKE_mesh_texspace_copy_from_object(ob->runtime.mesh_eval, ob);
2000   }
2001
2002   mesh_finalize_eval(ob);
2003
2004   ob->runtime.last_data_mask = *dataMask;
2005   ob->runtime.last_need_mapping = need_mapping;
2006
2007   if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
2008     /* create PBVH immediately (would be created on the fly too,
2009      * but this avoids waiting on first stroke) */
2010     /* XXX Disabled for now.
2011      * This can create horrible nasty bugs by generating re-entrant call of mesh_get_eval_final! */
2012     //      BKE_sculpt_update_mesh_elements(depsgraph, scene, scene->toolsettings->sculpt, ob, false, false);
2013   }
2014
2015   mesh_runtime_check_normals_valid(ob->runtime.mesh_eval);
2016   mesh_build_extra_data(depsgraph, ob);
2017 }
2018
2019 static void editbmesh_build_data(struct Depsgraph *depsgraph,
2020                                  Scene *scene,
2021                                  Object *obedit,
2022                                  BMEditMesh *em,
2023                                  CustomData_MeshMasks *dataMask)
2024 {
2025   BLI_assert(em->ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
2026
2027   BKE_object_free_derived_caches(obedit);
2028   BKE_object_sculpt_modifiers_changed(obedit);
2029
2030   BKE_editmesh_free_derivedmesh(em);
2031
2032   Mesh *me_cage;
2033   Mesh *me_final;
2034
2035   editbmesh_calc_modifiers(depsgraph, scene, obedit, em, dataMask, &me_cage, &me_final);
2036
2037   em->mesh_eval_final = me_final;
2038   em->mesh_eval_cage = me_cage;
2039
2040   BKE_object_boundbox_calc_from_mesh(obedit, em->mesh_eval_final);
2041
2042   em->lastDataMask = *dataMask;
2043
2044   mesh_runtime_check_normals_valid(em->mesh_eval_final);
2045 }
2046
2047 static void object_get_datamask(const Depsgraph *depsgraph,
2048                                 Object *ob,
2049                                 CustomData_MeshMasks *r_mask,
2050                                 bool *r_need_mapping)
2051 {
2052   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2053   Object *actob = view_layer->basact ? DEG_get_original_object(view_layer->basact->object) : NULL;
2054
2055   DEG_get_customdata_mask_for_object(depsgraph, ob, r_mask);
2056
2057   if (r_need_mapping) {
2058     *r_need_mapping = false;
2059   }
2060
2061   if (DEG_get_original_object(ob) == actob) {
2062     bool editing = BKE_paint_select_face_test(actob);
2063
2064     /* weight paint and face select need original indices because of selection buffer drawing */
2065     if (r_need_mapping) {
2066       *r_need_mapping = (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT | OB_MODE_VERTEX_PAINT)));
2067     }
2068
2069     /* check if we need tfaces & mcols due to face select or texture paint */
2070     if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
2071       r_mask->lmask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
2072       r_mask->fmask |= CD_MASK_MTFACE;
2073     }
2074
2075     /* check if we need mcols due to vertex paint or weightpaint */
2076     if (ob->mode & OB_MODE_VERTEX_PAINT) {
2077       r_mask->lmask |= CD_MASK_MLOOPCOL;
2078     }
2079
2080     if (ob->mode & OB_MODE_WEIGHT_PAINT) {
2081       r_mask->vmask |= CD_MASK_MDEFORMVERT;
2082     }
2083
2084     if (ob->mode & OB_MODE_EDIT) {
2085       r_mask->vmask |= CD_MASK_MVERT_SKIN;
2086     }
2087   }
2088 }
2089
2090 void makeDerivedMesh(struct Depsgraph *depsgraph,
2091                      Scene *scene,
2092                      Object *ob,
2093                      BMEditMesh *em,
2094                      const CustomData_MeshMasks *dataMask)
2095 {
2096   bool need_mapping;
2097   CustomData_MeshMasks cddata_masks = *dataMask;
2098   object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
2099
2100   if (em) {
2101     editbmesh_build_data(depsgraph, scene, ob, em, &cddata_masks);
2102   }
2103   else {
2104     mesh_build_data(depsgraph, scene, ob, &cddata_masks, need_mapping);
2105   }
2106 }
2107
2108 /***/
2109
2110 Mesh *mesh_get_eval_final(struct Depsgraph *depsgraph,
2111                           Scene *scene,
2112                           Object *ob,
2113                           const CustomData_MeshMasks *dataMask)
2114 {
2115   /* This function isn't thread-safe and can't be used during evaluation. */
2116   BLI_assert(DEG_debug_is_evaluating(depsgraph) == false);
2117
2118   /* Evaluated meshes aren't supposed to be created on original instances. If you do,
2119    * they aren't cleaned up properly on mode switch, causing crashes, e.g T58150. */
2120   BLI_assert(ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
2121
2122   /* if there's no evaluated mesh or the last data mask used doesn't include
2123    * the data we need, rebuild the derived mesh
2124    */
2125   bool need_mapping;
2126   CustomData_MeshMasks cddata_masks = *dataMask;
2127   object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
2128
2129   if (!ob->runtime.mesh_eval ||
2130       !CustomData_MeshMasks_are_matching(&(ob->runtime.last_data_mask), &cddata_masks) ||
2131       (need_mapping && !ob->runtime.last_need_mapping)) {
2132     CustomData_MeshMasks_update(&cddata_masks, &ob->runtime.last_data_mask);
2133     mesh_build_data(
2134         depsgraph, scene, ob, &cddata_masks, need_mapping || ob->runtime.last_need_mapping);
2135   }
2136
2137   if (ob->runtime.mesh_eval) {
2138     BLI_assert(!(ob->runtime.mesh_eval->runtime.cd_dirty_vert & CD_MASK_NORMAL));
2139   }
2140   return ob->runtime.mesh_eval;
2141 }
2142
2143 Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph,
2144                            Scene *scene,
2145                            Object *ob,
2146                            const CustomData_MeshMasks *dataMask)
2147 {
2148   /* This function isn't thread-safe and can't be used during evaluation. */
2149   BLI_assert(DEG_debug_is_evaluating(depsgraph) == false);
2150
2151   /* Evaluated meshes aren't supposed to be created on original instances. If you do,
2152    * they aren't cleaned up properly on mode switch, causing crashes, e.g T58150. */
2153   BLI_assert(ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
2154
2155   /* if there's no derived mesh or the last data mask used doesn't include
2156    * the data we need, rebuild the derived mesh
2157    */
2158   bool need_mapping;
2159
2160   CustomData_MeshMasks cddata_masks = *dataMask;
2161   object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
2162
2163   if (!ob->runtime.mesh_deform_eval ||
2164       !CustomData_MeshMasks_are_matching(&(ob->runtime.last_data_mask), &cddata_masks) ||
2165       (need_mapping && !ob->runtime.last_need_mapping)) {
2166     CustomData_MeshMasks_update(&cddata_masks, &ob->runtime.last_data_mask);
2167     mesh_build_data(
2168         depsgraph, scene, ob, &cddata_masks, need_mapping || ob->runtime.last_need_mapping);
2169   }
2170
2171   return ob->runtime.mesh_deform_eval;
2172 }
2173
2174 Mesh *mesh_create_eval_final_render(Depsgraph *depsgraph,
2175                                     Scene *scene,
2176                                     Object *ob,
2177                                     const CustomData_MeshMasks *dataMask)
2178 {
2179   Mesh *final;
2180
2181   mesh_calc_modifiers(depsgraph, scene, ob, 1, false, dataMask, -1, false, NULL, &final);
2182
2183   return final;
2184 }
2185
2186 Mesh *mesh_create_eval_final_index_render(Depsgraph *depsgraph,
2187                                           Scene *scene,
2188                                           Object *ob,
2189                                           const CustomData_MeshMasks *dataMask,
2190                                           int index)
2191 {
2192   Mesh *final;
2193
2194   mesh_calc_modifiers(depsgraph, scene, ob, 1, false, dataMask, index, false, NULL, &final);
2195
2196   return final;
2197 }
2198
2199 Mesh *mesh_create_eval_final_view(Depsgraph *depsgraph,
2200                                   Scene *scene,
2201                                   Object *ob,
2202                                   const CustomData_MeshMasks *dataMask)
2203 {
2204   Mesh *final;
2205
2206   /* XXX hack
2207    * psys modifier updates particle state when called during dupli-list generation,
2208    * which can lead to wrong transforms. This disables particle system modifier execution.
2209    */
2210   ob->transflag |= OB_NO_PSYS_UPDATE;
2211
2212   mesh_calc_modifiers(depsgraph, scene, ob, 1, false, dataMask, -1, false, NULL, &final);
2213
2214   ob->transflag &= ~OB_NO_PSYS_UPDATE;
2215
2216   return final;
2217 }
2218
2219 Mesh *mesh_create_eval_no_deform(Depsgraph *depsgraph,
2220                                  Scene *scene,
2221                                  Object *ob,
2222                                  const CustomData_MeshMasks *dataMask)
2223 {
2224   Mesh *final;
2225
2226   mesh_calc_modifiers(depsgraph, scene, ob, 0, false, dataMask, -1, false, NULL, &final);
2227
2228   return final;
2229 }
2230
2231 Mesh *mesh_create_eval_no_deform_render(Depsgraph *depsgraph,
2232                                         Scene *scene,
2233                                         Object *ob,
2234                                         const CustomData_MeshMasks *dataMask)
2235 {
2236   Mesh *final;
2237
2238   mesh_calc_modifiers(depsgraph, scene, ob, 0, false, dataMask, -1, false, NULL, &final);
2239
2240   return final;
2241 }
2242
2243 /***/
2244
2245 Mesh *editbmesh_get_eval_cage_and_final(Depsgraph *depsgraph,
2246                                         Scene *scene,
2247                                         Object *obedit,
2248                                         BMEditMesh *em,
2249                                         const CustomData_MeshMasks *dataMask,
2250                                         /* return args */
2251                                         Mesh **r_final)
2252 {
2253   CustomData_MeshMasks cddata_masks = *dataMask;
2254
2255   /* if there's no derived mesh or the last data mask used doesn't include
2256    * the data we need, rebuild the derived mesh
2257    */
2258   object_get_datamask(depsgraph, obedit, &cddata_masks, NULL);
2259
2260   if (!em->mesh_eval_cage ||
2261       !CustomData_MeshMasks_are_matching(&(em->lastDataMask), &cddata_masks)) {
2262     editbmesh_build_data(depsgraph, scene, obedit, em, &cddata_masks);
2263   }
2264
2265   *r_final = em->mesh_eval_final;
2266   if (em->mesh_eval_final) {
2267     BLI_assert(!(em->mesh_eval_final->runtime.cd_dirty_vert & DM_DIRTY_NORMALS));
2268   }
2269   return em->mesh_eval_cage;
2270 }
2271
2272 Mesh *editbmesh_get_eval_cage(struct Depsgraph *depsgraph,
2273                               Scene *scene,
2274                               Object *obedit,
2275                               BMEditMesh *em,
2276                               const CustomData_MeshMasks *dataMask)
2277 {
2278   CustomData_MeshMasks cddata_masks = *dataMask;
2279
2280   /* if there's no derived mesh or the last data mask used doesn't include
2281    * the data we need, rebuild the derived mesh
2282    */
2283   object_get_datamask(depsgraph, obedit, &cddata_masks, NULL);
2284
2285   if (!em->mesh_eval_cage ||
2286       !CustomData_MeshMasks_are_matching(&(em->lastDataMask), &cddata_masks)) {
2287     editbmesh_build_data(depsgraph, scene, obedit, em, &cddata_masks);
2288   }
2289
2290   return em->mesh_eval_cage;
2291 }
2292
2293 Mesh *editbmesh_get_eval_cage_from_orig(struct Depsgraph *depsgraph,
2294                                         Scene *scene,
2295                                         Object *obedit,
2296                                         BMEditMesh *UNUSED(em),
2297                                         const CustomData_MeshMasks *dataMask)
2298 {
2299   BLI_assert((obedit->id.tag & LIB_TAG_COPIED_ON_WRITE) == 0);
2300   Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
2301   Object *obedit_eval = (Object *)DEG_get_evaluated_id(depsgraph, &obedit->id);
2302   BMEditMesh *em_eval = BKE_editmesh_from_object(obedit_eval);
2303   return editbmesh_get_eval_cage(depsgraph, scene_eval, obedit_eval, em_eval, dataMask);
2304 }
2305
2306 /***/
2307
2308 /* same as above but for vert coords */
2309 typedef struct {
2310   float (*vertexcos)[3];
2311   BLI_bitmap *vertex_visit;
2312 } MappedUserData;
2313
2314 static void make_vertexcos__mapFunc(void *userData,
2315                                     int index,
2316                                     const float co[3],
2317                                     const float UNUSED(no_f[3]),
2318                                     const short UNUSED(no_s[3]))
2319 {
2320   MappedUserData *mappedData = (MappedUserData *)userData;
2321
2322   if (BLI_BITMAP_TEST(mappedData->vertex_visit, index) == 0) {
2323     /* we need coord from prototype vertex, not from copies,
2324      * assume they stored in the beginning of vertex array stored in DM
2325      * (mirror modifier for eg does this) */
2326     copy_v3_v3(mappedData->vertexcos[index], co);
2327     BLI_BITMAP_ENABLE(mappedData->vertex_visit, index);
2328   }
2329 }
2330
2331 void mesh_get_mapped_verts_coords(Mesh *me_eval, float (*r_cos)[3], const int totcos)
2332 {
2333   if (me_eval->runtime.deformed_only == false) {
2334     MappedUserData userData;
2335     memset(r_cos, 0, sizeof(*r_cos) * totcos);
2336     userData.vertexcos = r_cos;
2337     userData.vertex_visit = BLI_BITMAP_NEW(totcos, "vertexcos flags");
2338     BKE_mesh_foreach_mapped_vert(me_eval, make_vertexcos__mapFunc, &userData, MESH_FOREACH_NOP);
2339     MEM_freeN(userData.vertex_visit);
2340   }
2341   else {
2342     MVert *mv = me_eval->mvert;
2343     for (int i = 0; i < totcos; i++, mv++) {
2344       copy_v3_v3(r_cos[i], mv->co);
2345     }
2346   }
2347 }
2348
2349 void DM_calc_loop_tangents(DerivedMesh *dm,
2350                            bool calc_active_tangent,
2351                            const char (*tangent_names)[MAX_NAME],
2352                            int tangent_names_len)
2353 {
2354   BKE_mesh_calc_loop_tangent_ex(dm->getVertArray(dm),
2355                                 dm->getPolyArray(dm),
2356                                 dm->getNumPolys(dm),
2357                                 dm->getLoopArray(dm),
2358                                 dm->getLoopTriArray(dm),
2359                                 dm->getNumLoopTri(dm),
2360                                 &dm->loopData,
2361                                 calc_active_tangent,
2362                                 tangent_names,
2363                                 tangent_names_len,
2364                                 CustomData_get_layer(&dm->polyData, CD_NORMAL),
2365                                 dm->getLoopDataArray(dm, CD_NORMAL),
2366                                 dm->getVertDataArray(dm, CD_ORCO), /* may be NULL */
2367                                 /* result */
2368                                 &dm->loopData,
2369                                 dm->getNumLoops(dm),
2370                                 &dm->tangent_mask);
2371 }
2372
2373 static void mesh_init_origspace(Mesh *mesh)
2374 {
2375   const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2376
2377   OrigSpaceLoop *lof_array = CustomData_get_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP);
2378   const int numpoly = mesh->totpoly;
2379   // const int numloop = mesh->totloop;
2380   MVert *mv = mesh->mvert;
2381   MLoop *ml = mesh->mloop;
2382   MPoly *mp = mesh->mpoly;
2383   int i, j, k;
2384
2385   float(*vcos_2d)[2] = NULL;
2386   BLI_array_staticdeclare(vcos_2d, 64);
2387
2388   for (i = 0; i < numpoly; i++, mp++) {
2389     OrigSpaceLoop *lof = lof_array + mp->loopstart;
2390
2391     if (mp->totloop == 3 || mp->totloop == 4) {
2392       for (j = 0; j < mp->totloop; j++, lof++) {
2393         copy_v2_v2(lof->uv, default_osf[j]);
2394       }
2395     }
2396     else {
2397       MLoop *l = &ml[mp->loopstart];
2398       float p_nor[3], co[3];
2399       float mat[3][3];
2400
2401       float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2402       float translate[2], scale[2];
2403
2404       BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2405       axis_dominant_v3_to_m3(mat, p_nor);
2406
2407       BLI_array_clear(vcos_2d);
2408       BLI_array_reserve(vcos_2d, mp->totloop);
2409       for (j = 0; j < mp->totloop; j++, l++) {
2410         mul_v3_m3v3(co, mat, mv[l->v].co);
2411         copy_v2_v2(vcos_2d[j], co);
2412
2413         for (k = 0; k < 2; k++) {
2414           if (co[k] > max[k]) {
2415             max[k] = co[k];
2416           }
2417           else if (co[k] < min[k]) {
2418             min[k] = co[k];
2419           }
2420         }
2421       }
2422
2423       /* Brings min to (0, 0). */
2424       negate_v2_v2(translate, min);
2425
2426       /* Scale will bring max to (1, 1). */
2427       sub_v2_v2v2(scale, max, min);
2428       if (scale[0] == 0.0f) {
2429         scale[0] = 1e-9f;
2430       }
2431       if (scale[1] == 0.0f) {
2432         scale[1] = 1e-9f;
2433       }
2434       invert_v2(scale);
2435
2436       /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2437       for (j = 0; j < mp->totloop; j++, lof++) {
2438         add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2439         mul_v2_v2(lof->uv, scale);
2440       }
2441     }
2442   }
2443
2444   BKE_mesh_tessface_clear(mesh);
2445   BLI_array_free(vcos_2d);
2446 }
2447
2448 /* derivedmesh info printing function,
2449  * to help track down differences DM output */
2450
2451 #ifndef NDEBUG
2452 #  include "BLI_dynstr.h"
2453
2454 static void dm_debug_info_layers(DynStr *dynstr,
2455                                  DerivedMesh *dm,
2456                                  CustomData *cd,
2457                                  void *(*getElemDataArray)(DerivedMesh *, int))
2458 {
2459   int type;
2460
2461   for (type = 0; type < CD_NUMTYPES; type++) {
2462     if (CustomData_has_layer(cd, type)) {
2463       /* note: doesn't account for multiple layers */
2464       const char *name = CustomData_layertype_name(type);
2465       const int size = CustomData_sizeof(type);
2466       const void *pt = getElemDataArray(dm, type);
2467       const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
2468       const char *structname;
2469       int structnum;
2470       CustomData_file_write_info(type, &structname, &structnum);
2471       BLI_dynstr_appendf(
2472           dynstr,
2473           "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2474           name,
2475           structname,
2476           type,
2477           (const void *)pt,
2478           size,
2479           pt_size);
2480     }
2481   }
2482 }
2483
2484 char *DM_debug_info(DerivedMesh *dm)
2485 {
2486   DynStr *dynstr = BLI_dynstr_new();
2487   char *ret;
2488   const char *tstr;
2489
2490   BLI_dynstr_append(dynstr, "{\n");
2491   BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)dm);
2492   switch (dm->type) {
2493     case DM_TYPE_CDDM:
2494       tstr = "DM_TYPE_CDDM";
2495       break;
2496     case DM_TYPE_CCGDM:
2497       tstr = "DM_TYPE_CCGDM";
2498       break;
2499     default:
2500       tstr = "UNKNOWN";
2501       break;
2502   }
2503   BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
2504   BLI_dynstr_appendf(dynstr, "    'numVertData': %d,\n", dm->numVertData);
2505   BLI_dynstr_appendf(dynstr, "    'numEdgeData': %d,\n", dm->numEdgeData);
2506   BLI_dynstr_appendf(dynstr, "    'numTessFaceData': %d,\n", dm->numTessFaceData);
2507   BLI_dynstr_appendf(dynstr, "    'numPolyData': %d,\n", dm->numPolyData);
2508   BLI_dynstr_appendf(dynstr, "    'deformedOnly': %d,\n", dm->deformedOnly);
2509
2510   BLI_dynstr_append(dynstr, "    'vertexLayers': (\n");
2511   dm_debug_info_layers(dynstr, dm, &dm->vertData, dm->getVertDataArray);
2512   BLI_dynstr_append(dynstr, "    ),\n");
2513
2514   BLI_dynstr_append(dynstr, "    'edgeLayers': (\n");
2515   dm_debug_info_layers(dynstr, dm, &dm->edgeData, dm->getEdgeDataArray);
2516   BLI_dynstr_append(dynstr, "    ),\n");
2517
2518   BLI_dynstr_append(dynstr, "    'loopLayers': (\n");
2519   dm_debug_info_layers(dynstr, dm, &dm->loopData, dm->getLoopDataArray);
2520   BLI_dynstr_append(dynstr, "    ),\n");
2521
2522   BLI_dynstr_append(dynstr, "    'polyLayers': (\n");
2523   dm_debug_info_layers(dynstr, dm, &dm->polyData, dm->getPolyDataArray);
2524   BLI_dynstr_append(dynstr, "    ),\n");
2525
2526   BLI_dynstr_append(dynstr, "    'tessFaceLayers': (\n");
2527   dm_debug_info_layers(dynstr, dm, &dm->faceData, dm->getTessFaceDataArray);
2528   BLI_dynstr_append(dynstr, "    ),\n");
2529
2530   BLI_dynstr_append(dynstr, "}\n");
2531
2532   ret = BLI_dynstr_get_cstring(dynstr);
2533   BLI_dynstr_free(dynstr);
2534   return ret;
2535 }
2536
2537 void DM_debug_print(DerivedMesh *dm)
2538 {
2539   char *str = DM_debug_info(dm);
2540   puts(str);
2541   fflush(stdout);
2542   MEM_freeN(str);
2543 }
2544
2545 void DM_debug_print_cdlayers(CustomData *data)
2546 {
2547   int i;
2548   const CustomDataLayer *layer;
2549
2550   printf("{\n");
2551
2552   for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
2553
2554     const char *name = CustomData_layertype_name(layer->type);
2555     const int size = CustomData_sizeof(layer->type);
2556     const char *structname;
2557     int structnum;
2558     CustomData_file_write_info(layer->type, &structname, &structnum);
2559     printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2560            name,
2561            structname,
2562            layer->type,
2563            (const void *)layer->data,
2564            size,
2565            (int)(MEM_allocN_len(layer->data) / size));
2566   }
2567
2568   printf("}\n");
2569 }
2570
2571 bool DM_is_valid(DerivedMesh *dm)
2572 {
2573   const bool do_verbose = true;
2574   const bool do_fixes = false;
2575
2576   bool is_valid = true;
2577   bool changed = true;
2578
2579   is_valid &= BKE_mesh_validate_all_customdata(
2580       dm->getVertDataLayout(dm),
2581       dm->getNumVerts(dm),
2582       dm->getEdgeDataLayout(dm),
2583       dm->getNumEdges(dm),
2584       dm->getLoopDataLayout(dm),
2585       dm->getNumLoops(dm),
2586       dm->getPolyDataLayout(dm),
2587       dm->getNumPolys(dm),
2588       false, /* setting mask here isn't useful, gives false positives */
2589       do_verbose,
2590       do_fixes,
2591       &changed);
2592
2593   is_valid &= BKE_mesh_validate_arrays(NULL,
2594                                        dm->getVertArray(dm),
2595                                        dm->getNumVerts(dm),
2596                                        dm->getEdgeArray(dm),
2597                                        dm->getNumEdges(dm),
2598                                        dm->getTessFaceArray(dm),
2599                                        dm->getNumTessFaces(dm),
2600                                        dm->getLoopArray(dm),
2601                                        dm->getNumLoops(dm),
2602                                        dm->getPolyArray(dm),
2603                                        dm->getNumPolys(dm),
2604                                        dm->getVertDataArray(dm, CD_MDEFORMVERT),
2605                                        do_verbose,
2606                                        do_fixes,
2607                                        &changed);
2608
2609   BLI_assert(changed == false);
2610
2611   return is_valid;
2612 }
2613
2614 #endif /* NDEBUG */