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