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