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