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