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