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