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