Fix usage of mesh_get_eval_final in vertex selection.
[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_calc_modifiers(
1155         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
1156         int useDeform,
1157         const bool need_mapping, CustomDataMask dataMask,
1158         const int index, const bool useCache, const bool build_shapekey_layers,
1159         /* return args */
1160         Mesh **r_deform, Mesh **r_final)
1161 {
1162         ModifierData *firstmd, *md, *previewmd = NULL;
1163         CDMaskLink *datamasks, *curr;
1164         /* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
1165         CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX;
1166         float (*deformedVerts)[3] = NULL;
1167         int numVerts = ((Mesh *)ob->data)->totvert;
1168         const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
1169         const int required_mode = useRenderParams ? eModifierMode_Render : eModifierMode_Realtime;
1170         bool isPrevDeform = false;
1171         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
1172         const bool has_multires = (mmd && mmd->sculptlvl != 0);
1173         bool multires_applied = false;
1174         const bool sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt && !useRenderParams;
1175         const bool sculpt_dyntopo = (sculpt_mode && ob->sculpt->bm)  && !useRenderParams;
1176
1177         /* Generic preview only in object mode! */
1178         const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
1179         const bool do_loop_normals = (((Mesh *)ob->data)->flag & ME_AUTOSMOOTH) != 0;
1180
1181         VirtualModifierData virtualModifierData;
1182
1183         ModifierApplyFlag app_flags = useRenderParams ? MOD_APPLY_RENDER : 0;
1184         ModifierApplyFlag deform_app_flags = app_flags;
1185
1186         BLI_assert((((Mesh *)ob->data)->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
1187
1188         if (useCache)
1189                 app_flags |= MOD_APPLY_USECACHE;
1190         if (useDeform)
1191                 deform_app_flags |= MOD_APPLY_USECACHE;
1192
1193         /* TODO(sybren): do we really need three context objects? Or do we modify
1194          * them on the fly to change the flags where needed? */
1195         const ModifierEvalContext mectx_deform = {depsgraph, ob, deform_app_flags};
1196         const ModifierEvalContext mectx_apply = {depsgraph, ob, app_flags};
1197         const ModifierEvalContext mectx_orco = {depsgraph, ob, (app_flags & ~MOD_APPLY_USECACHE) | MOD_APPLY_ORCO};
1198
1199         md = firstmd = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1200
1201         modifiers_clearErrors(ob);
1202
1203         if (do_mod_mcol) {
1204                 /* Find the last active modifier generating a preview, or NULL if none. */
1205                 /* XXX Currently, DPaint modifier just ignores this.
1206                  *     Needs a stupid hack...
1207                  *     The whole "modifier preview" thing has to be (re?)designed, anyway! */
1208                 previewmd = modifiers_getLastPreview(scene, md, required_mode);
1209         }
1210
1211         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
1212         curr = datamasks;
1213
1214         if (r_deform) {
1215                 *r_deform = NULL;
1216         }
1217         *r_final = NULL;
1218
1219         if (useDeform) {
1220                 if (inputVertexCos)
1221                         deformedVerts = inputVertexCos;
1222
1223                 /* Apply all leading deforming modifiers */
1224                 for (; md; md = md->next, curr = curr->next) {
1225                         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1226
1227                         if (!modifier_isEnabled(scene, md, required_mode)) {
1228                                 continue;
1229                         }
1230
1231                         if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1232                                 continue;
1233                         }
1234
1235                         if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
1236                                 if (!deformedVerts)
1237                                         deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
1238
1239                                 modwrap_deformVerts(md, &mectx_deform, NULL, deformedVerts, numVerts);
1240                         }
1241                         else {
1242                                 break;
1243                         }
1244
1245                         /* grab modifiers until index i */
1246                         if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
1247                                 break;
1248                 }
1249
1250                 /* Result of all leading deforming modifiers is cached for
1251                  * places that wish to use the original mesh but with deformed
1252                  * coordinates (vpaint, etc.)
1253                  */
1254                 if (r_deform) {
1255                         *r_deform = BKE_mesh_copy_for_eval(ob->data, true);
1256
1257                         /* XXX: Is build_shapekey_layers ever even true? This should have crashed long ago... */
1258                         BLI_assert(!build_shapekey_layers);
1259                         if (build_shapekey_layers) {
1260                                 add_shapekey_layers(*r_deform, ob->data, ob);
1261                         }
1262
1263                         if (deformedVerts) {
1264                                 BKE_mesh_apply_vert_coords(*r_deform, deformedVerts);
1265                         }
1266                 }
1267         }
1268         else {
1269                 /* default behavior for meshes */
1270                 if (inputVertexCos)
1271                         deformedVerts = inputVertexCos;
1272                 else
1273                         deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
1274         }
1275
1276
1277         /* Now apply all remaining modifiers. If useDeform is off then skip
1278          * OnlyDeform ones.
1279          */
1280         Mesh *me = NULL;
1281         Mesh *me_orco = NULL;
1282         Mesh *me_orco_cloth = NULL;
1283
1284         for (; md; md = md->next, curr = curr->next) {
1285                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1286
1287                 if (!modifier_isEnabled(scene, md, required_mode)) {
1288                         continue;
1289                 }
1290
1291                 if (mti->type == eModifierTypeType_OnlyDeform && !useDeform) {
1292                         continue;
1293                 }
1294
1295                 if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && me) {
1296                         modifier_setError(md, "Modifier requires original data, bad stack position");
1297                         continue;
1298                 }
1299
1300                 if (sculpt_mode &&
1301                     (!has_multires || multires_applied || sculpt_dyntopo))
1302                 {
1303                         bool unsupported = false;
1304
1305                         if (md->type == eModifierType_Multires && ((MultiresModifierData *)md)->sculptlvl == 0) {
1306                                 /* If multires is on level 0 skip it silently without warning message. */
1307                                 if (!sculpt_dyntopo) {
1308                                         continue;
1309                                 }
1310                         }
1311
1312                         if (sculpt_dyntopo && !useRenderParams)
1313                                 unsupported = true;
1314
1315                         if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM)
1316                                 unsupported |= (mti->type != eModifierTypeType_OnlyDeform);
1317
1318                         unsupported |= multires_applied;
1319
1320                         if (unsupported) {
1321                                 if (sculpt_dyntopo)
1322                                         modifier_setError(md, "Not supported in dyntopo");
1323                                 else
1324                                         modifier_setError(md, "Not supported in sculpt mode");
1325                                 continue;
1326                         }
1327                         else {
1328                                 modifier_setError(md, "Hide, Mask and optimized display disabled");
1329                         }
1330                 }
1331
1332                 if (need_mapping && !modifier_supportsMapping(md)) {
1333                         continue;
1334                 }
1335
1336                 if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1337                         continue;
1338                 }
1339
1340                 /* add an orco layer if needed by this modifier */
1341                 if (mti->requiredDataMask)
1342                         mask = mti->requiredDataMask(ob, md);
1343                 else
1344                         mask = 0;
1345
1346                 if (me && (mask & CD_MASK_ORCO)) {
1347                         add_orco_mesh(ob, NULL, me, me_orco, CD_ORCO);
1348                 }
1349
1350                 /* How to apply modifier depends on (a) what we already have as
1351                  * a result of previous modifiers (could be a Mesh or just
1352                  * deformed vertices) and (b) what type the modifier is.
1353                  */
1354
1355                 if (mti->type == eModifierTypeType_OnlyDeform) {
1356                         /* No existing verts to deform, need to build them. */
1357                         if (!deformedVerts) {
1358                                 if (me) {
1359                                         /* Deforming a mesh, read the vertex locations
1360                                          * out of the mesh and deform them. Once done with this
1361                                          * run of deformers verts will be written back.
1362                                          */
1363                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1364                                 }
1365                                 else {
1366                                         deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
1367                                 }
1368                         }
1369
1370                         /* if this is not the last modifier in the stack then recalculate the normals
1371                          * to avoid giving bogus normals to the next modifier see: [#23673] */
1372                         if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1373                                 /* XXX, this covers bug #23673, but we may need normal calc for other types */
1374                                 if (me) {
1375                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
1376                                 }
1377                         }
1378
1379                         modwrap_deformVerts(md, &mectx_deform, me, deformedVerts, numVerts);
1380                 }
1381                 else {
1382                         /* determine which data layers are needed by following modifiers */
1383                         if (curr->next)
1384                                 nextmask = curr->next->mask;
1385                         else
1386                                 nextmask = dataMask;
1387
1388                         /* apply vertex coordinates or build a Mesh as necessary */
1389                         if (me) {
1390                                 if (deformedVerts) {
1391                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
1392                                 }
1393                         }
1394                         else {
1395                                 me = BKE_mesh_copy_for_eval(ob->data, true);
1396                                 ASSERT_IS_VALID_MESH(me);
1397
1398                                 if (build_shapekey_layers) {
1399                                         add_shapekey_layers(me, ob->data, ob);
1400                                 }
1401
1402                                 if (deformedVerts) {
1403                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
1404                                 }
1405
1406                                 /* Constructive modifiers need to have an origindex
1407                                  * otherwise they wont have anywhere to copy the data from.
1408                                  *
1409                                  * Also create ORIGINDEX data if any of the following modifiers
1410                                  * requests it, this way Mirror, Solidify etc will keep ORIGINDEX
1411                                  * data by using generic DM_copy_vert_data() functions.
1412                                  */
1413                                 if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
1414                                         /* calc */
1415                                         CustomData_add_layer(&me->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totvert);
1416                                         CustomData_add_layer(&me->edata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totedge);
1417                                         CustomData_add_layer(&me->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totpoly);
1418
1419                                         /* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
1420                                         range_vn_i(CustomData_get_layer(&me->vdata, CD_ORIGINDEX), me->totvert, 0);
1421                                         range_vn_i(CustomData_get_layer(&me->edata, CD_ORIGINDEX), me->totedge, 0);
1422                                         range_vn_i(CustomData_get_layer(&me->pdata, CD_ORIGINDEX), me->totpoly, 0);
1423                                 }
1424                         }
1425
1426
1427                         /* set the Mesh to only copy needed data */
1428                         mask = curr->mask;
1429                         /* needMapping check here fixes bug [#28112], otherwise it's
1430                          * possible that it won't be copied */
1431                         mask |= append_mask;
1432                         mesh_set_only_copy(me, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
1433
1434                         /* add cloth rest shape key if needed */
1435                         if (mask & CD_MASK_CLOTH_ORCO)
1436                                 add_orco_mesh(ob, NULL, me, me_orco, CD_CLOTH_ORCO);
1437
1438                         /* add an origspace layer if needed */
1439                         if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
1440                                 if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
1441                                         CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
1442                                         mesh_init_origspace(me);
1443                                 }
1444                         }
1445
1446                         Mesh *me_next = modwrap_applyModifier(md, &mectx_apply, me);
1447                         ASSERT_IS_VALID_MESH(me_next);
1448
1449                         if (me_next) {
1450                                 /* if the modifier returned a new mesh, release the old one */
1451                                 if (me && me != me_next) {
1452                                         BLI_assert(me != ob->data);
1453                                         BKE_id_free(NULL, me);
1454                                 }
1455                                 me = me_next;
1456
1457                                 if (deformedVerts) {
1458                                         if (deformedVerts != inputVertexCos) {
1459                                                 MEM_freeN(deformedVerts);
1460                                         }
1461                                         deformedVerts = NULL;
1462                                 }
1463                         }
1464
1465                         /* create an orco mesh in parallel */
1466                         if (nextmask & CD_MASK_ORCO) {
1467                                 if (!me_orco) {
1468                                         me_orco = create_orco_mesh(ob, ob->data, NULL, CD_ORCO);
1469                                 }
1470
1471                                 nextmask &= ~CD_MASK_ORCO;
1472                                 mesh_set_only_copy(me_orco, nextmask | CD_MASK_ORIGINDEX |
1473                                                  (mti->requiredDataMask ?
1474                                                   mti->requiredDataMask(ob, md) : 0));
1475
1476                                 me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
1477                                 ASSERT_IS_VALID_MESH(me_next);
1478
1479                                 if (me_next) {
1480                                         /* if the modifier returned a new mesh, release the old one */
1481                                         if (me_orco && me_orco != me_next) {
1482                                                 BLI_assert(me_orco != ob->data);
1483                                                 BKE_id_free(NULL, me_orco);
1484                                         }
1485
1486                                         me_orco = me_next;
1487                                 }
1488                         }
1489
1490                         /* create cloth orco mesh in parallel */
1491                         if (nextmask & CD_MASK_CLOTH_ORCO) {
1492                                 if (!me_orco_cloth) {
1493                                         me_orco_cloth = create_orco_mesh(ob, ob->data, NULL, CD_CLOTH_ORCO);
1494                                 }
1495
1496                                 nextmask &= ~CD_MASK_CLOTH_ORCO;
1497                                 mesh_set_only_copy(me_orco_cloth, nextmask | CD_MASK_ORIGINDEX);
1498
1499                                 me_next = modwrap_applyModifier(md, &mectx_orco, me_orco_cloth);
1500                                 ASSERT_IS_VALID_DM(me_next);
1501
1502                                 if (me_next) {
1503                                         /* if the modifier returned a new mesh, release the old one */
1504                                         if (me_orco_cloth && me_orco_cloth != me_next) {
1505                                                 BLI_assert(me_orco != ob->data);
1506                                                 BKE_id_free(NULL, me_orco_cloth);
1507                                         }
1508
1509                                         me_orco_cloth = me_next;
1510                                 }
1511                         }
1512
1513                         /* in case of dynamic paint, make sure preview mask remains for following modifiers */
1514                         /* XXX Temp and hackish solution! */
1515                         if (md->type == eModifierType_DynamicPaint)
1516                                 append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
1517
1518                         me->runtime.deformed_only = false;
1519                 }
1520
1521                 isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
1522
1523                 /* grab modifiers until index i */
1524                 if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
1525                         break;
1526
1527                 if (sculpt_mode && md->type == eModifierType_Multires) {
1528                         multires_applied = true;
1529                 }
1530         }
1531
1532         for (md = firstmd; md; md = md->next)
1533                 modifier_freeTemporaryData(md);
1534
1535         /* Yay, we are done. If we have a Mesh and deformed vertices
1536          * need to apply these back onto the Mesh. If we have no
1537          * Mesh then we need to build one.
1538          */
1539         if (me) {
1540                 *r_final = me;
1541
1542                 if (deformedVerts) {
1543                         BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
1544                 }
1545         }
1546         else {
1547                 *r_final = BKE_mesh_copy_for_eval(ob->data, true);
1548
1549                 if (build_shapekey_layers) {
1550                         add_shapekey_layers(*r_final, ob->data, ob);
1551                 }
1552
1553                 if (deformedVerts) {
1554                         BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
1555                 }
1556         }
1557
1558         /* add an orco layer if needed */
1559         if (dataMask & CD_MASK_ORCO) {
1560                 add_orco_mesh(ob, NULL, *r_final, me_orco, CD_ORCO);
1561
1562                 if (r_deform && *r_deform)
1563                         add_orco_mesh(ob, NULL, *r_deform, NULL, CD_ORCO);
1564         }
1565
1566         if (do_loop_normals) {
1567                 /* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
1568                 BKE_mesh_calc_normals_split(*r_final);
1569                 BKE_mesh_tessface_clear(*r_final);
1570         }
1571
1572         if (sculpt_dyntopo == false) {
1573                 /* watch this! after 2.75a we move to from tessface to looptri (by default) */
1574                 if (dataMask & CD_MASK_MFACE) {
1575                         BKE_mesh_tessface_ensure(*r_final);
1576                 }
1577
1578                 /* without this, drawing ngon tri's faces will show ugly tessellated face
1579                  * normals and will also have to calculate normals on the fly, try avoid
1580                  * this where possible since calculating polygon normals isn't fast,
1581                  * note that this isn't a problem for subsurf (only quads) or editmode
1582                  * which deals with drawing differently.
1583                  *
1584                  * Only calc vertex normals if they are flagged as dirty.
1585                  * If using loop normals, poly nors have already been computed.
1586                  */
1587                 if (!do_loop_normals) {
1588                         BKE_mesh_ensure_normals_for_display(*r_final);
1589                 }
1590         }
1591
1592         /* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
1593          * as they are used by display code when available (i.e. even if autosmooth is disabled). */
1594         if (!do_loop_normals && CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
1595                 CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
1596         }
1597
1598         if (me_orco) {
1599                 BKE_id_free(NULL, me_orco);
1600         }
1601         if (me_orco_cloth) {
1602                 BKE_id_free(NULL, me_orco_cloth);
1603         }
1604
1605         if (deformedVerts && deformedVerts != inputVertexCos)
1606                 MEM_freeN(deformedVerts);
1607
1608         BLI_linklist_free((LinkNode *)datamasks, NULL);
1609 }
1610
1611 static void mesh_calc_modifiers_dm(
1612         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
1613         int useDeform,
1614         const bool need_mapping, CustomDataMask dataMask,
1615         const int index, const bool useCache, const bool build_shapekey_layers,
1616         /* return args */
1617         DerivedMesh **r_deformdm, DerivedMesh **r_finaldm)
1618 {
1619         Mesh *deform_mesh = NULL, *final_mesh = NULL;
1620
1621         mesh_calc_modifiers(
1622                 depsgraph, scene, ob, inputVertexCos, useDeform,
1623                 need_mapping, dataMask, index, useCache, build_shapekey_layers,
1624                 (r_deformdm ? &deform_mesh : NULL), &final_mesh);
1625
1626         if (deform_mesh) {
1627                 *r_deformdm = CDDM_from_mesh_ex(deform_mesh, CD_DUPLICATE, CD_MASK_MESH);
1628                 BKE_id_free(NULL, deform_mesh);
1629         }
1630
1631         *r_finaldm = CDDM_from_mesh_ex(final_mesh, CD_DUPLICATE, CD_MASK_MESH);
1632         BKE_id_free(NULL, final_mesh);
1633 }
1634
1635 float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
1636 {
1637         BMIter iter;
1638         BMVert *eve;
1639         float (*cos)[3];
1640         int i;
1641
1642         *r_numVerts = em->bm->totvert;
1643
1644         cos = MEM_malloc_arrayN(em->bm->totvert, 3 * sizeof(float), "vertexcos");
1645
1646         BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
1647                 copy_v3_v3(cos[i], eve->co);
1648         }
1649
1650         return cos;
1651 }
1652
1653 bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev_mesh)
1654 {
1655         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1656         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1657
1658         if (!modifier_isEnabled(scene, md, required_mode)) {
1659                 return false;
1660         }
1661
1662         if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && has_prev_mesh) {
1663                 modifier_setError(md, "Modifier requires original data, bad stack position");
1664                 return false;
1665         }
1666
1667         return true;
1668 }
1669
1670 static void editbmesh_calc_modifiers(
1671         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
1672         BMEditMesh *em, CustomDataMask dataMask,
1673         /* return args */
1674         Mesh **r_cage, Mesh **r_final)
1675 {
1676         ModifierData *md;
1677         float (*deformedVerts)[3] = NULL;
1678         CustomDataMask mask = 0, append_mask = 0;
1679         int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
1680         CDMaskLink *datamasks, *curr;
1681         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1682         const bool do_init_statvis = false;  /* FIXME: use V3D_OVERLAY_EDIT_STATVIS. */
1683         VirtualModifierData virtualModifierData;
1684
1685         /* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
1686         const ModifierEvalContext mectx = {depsgraph, ob, 0};
1687         const ModifierEvalContext mectx_orco = {depsgraph, ob, MOD_APPLY_ORCO};
1688         const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE};
1689
1690         const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
1691
1692         modifiers_clearErrors(ob);
1693
1694         if (r_cage && cageIndex == -1) {
1695                 *r_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, dataMask, NULL);
1696         }
1697
1698         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1699
1700         /* copied from mesh_calc_modifiers */
1701         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
1702
1703         curr = datamasks;
1704
1705         Mesh *me = NULL;
1706         Mesh *me_orco = NULL;
1707
1708         for (i = 0; md; i++, md = md->next, curr = curr->next) {
1709                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1710
1711                 if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
1712                         continue;
1713                 }
1714
1715                 /* add an orco layer if needed by this modifier */
1716                 if (me && mti->requiredDataMask) {
1717                         mask = mti->requiredDataMask(ob, md);
1718                         if (mask & CD_MASK_ORCO) {
1719                                 add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
1720                         }
1721                 }
1722
1723                 /* How to apply modifier depends on (a) what we already have as
1724                  * a result of previous modifiers (could be a DerivedMesh or just
1725                  * deformed vertices) and (b) what type the modifier is.
1726                  */
1727
1728                 if (mti->type == eModifierTypeType_OnlyDeform) {
1729                         /* No existing verts to deform, need to build them. */
1730                         if (!deformedVerts) {
1731                                 if (me) {
1732                                         /* Deforming a derived mesh, read the vertex locations
1733                                          * out of the mesh and deform them. Once done with this
1734                                          * run of deformers verts will be written back.
1735                                          */
1736                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1737                                 }
1738                                 else {
1739                                         deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
1740                                 }
1741                         }
1742
1743                         if (mti->deformVertsEM)
1744                                 modwrap_deformVertsEM(md, &mectx, em, me, deformedVerts, numVerts);
1745                         else
1746                                 modwrap_deformVerts(md, &mectx, me, deformedVerts, numVerts);
1747                 }
1748                 else {
1749                         Mesh *me_next;
1750
1751                         /* apply vertex coordinates or build a DerivedMesh as necessary */
1752                         if (me) {
1753                                 if (deformedVerts) {
1754                                         Mesh *me_temp = BKE_mesh_copy_for_eval(me, false);
1755
1756                                         if (!(r_cage && me == *r_cage)) {
1757                                                 BKE_id_free(NULL, me);
1758                                         }
1759                                         me = me_temp;
1760                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
1761                                 }
1762                                 else if (r_cage && me == *r_cage) {
1763                                         /* 'me' may be changed by this modifier, so we need to copy it. */
1764                                         me = BKE_mesh_copy_for_eval(me, false);
1765                                 }
1766
1767                         }
1768                         else {
1769                                 me = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, 0);
1770                                 ASSERT_IS_VALID_MESH(me);
1771
1772                                 if (deformedVerts) {
1773                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
1774                                 }
1775                         }
1776
1777                         /* create an orco derivedmesh in parallel */
1778                         mask = curr->mask;
1779                         if (mask & CD_MASK_ORCO) {
1780                                 if (!me_orco) {
1781                                         me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
1782                                 }
1783
1784                                 mask &= ~CD_MASK_ORCO;
1785                                 mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
1786
1787                                 me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
1788                                 ASSERT_IS_VALID_MESH(me_next);
1789
1790                                 if (me_next) {
1791                                         /* if the modifier returned a new dm, release the old one */
1792                                         if (me_orco && me_orco != me_next) {
1793                                                 BKE_id_free(NULL, me_orco);
1794                                         }
1795                                         me_orco = me_next;
1796                                 }
1797                         }
1798
1799                         /* set the DerivedMesh to only copy needed data */
1800                         mask |= append_mask;
1801                         mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
1802
1803                         mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
1804
1805                         if (mask & CD_MASK_ORIGSPACE_MLOOP) {
1806                                 if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
1807                                         CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
1808                                         mesh_init_origspace(me);
1809                                 }
1810                         }
1811
1812                         me_next = modwrap_applyModifier(md, &mectx_cache, me);
1813                         ASSERT_IS_VALID_MESH(me_next);
1814
1815                         if (me_next) {
1816                                 if (me && me != me_next) {
1817                                         BKE_id_free(NULL, me);
1818                                 }
1819                                 me = me_next;
1820
1821                                 if (deformedVerts) {
1822                                         MEM_freeN(deformedVerts);
1823                                         deformedVerts = NULL;
1824                                 }
1825                         }
1826                         me->runtime.deformed_only = false;
1827                 }
1828
1829                 if (r_cage && i == cageIndex) {
1830                         if (me && deformedVerts) {
1831                                 *r_cage = BKE_mesh_copy_for_eval(me, false);
1832                                 BKE_mesh_apply_vert_coords(*r_cage, deformedVerts);
1833                         }
1834                         else if (me) {
1835                                 *r_cage = me;
1836                         }
1837                         else {
1838                                 Mesh *me_orig = ob->data;
1839                                 if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
1840                                         BKE_mesh_runtime_ensure_edit_data(me_orig);
1841                                         me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
1842                                 }
1843                                 *r_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(
1844                                         em, mask,
1845                                         deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
1846                         }
1847                 }
1848         }
1849
1850         BLI_linklist_free((LinkNode *)datamasks, NULL);
1851
1852         /* Yay, we are done. If we have a DerivedMesh and deformed vertices need
1853          * to apply these back onto the DerivedMesh. If we have no DerivedMesh
1854          * then we need to build one.
1855          */
1856         if (me && deformedVerts) {
1857                 *r_final = BKE_mesh_copy_for_eval(me, false);
1858
1859                 if (!(r_cage && me == *r_cage)) {
1860                         BKE_id_free(NULL, me);
1861                 }
1862                 BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
1863         }
1864         else if (me) {
1865                 *r_final = me;
1866         }
1867         else if (!deformedVerts && r_cage && *r_cage) {
1868                 /* cage should already have up to date normals */
1869                 *r_final = *r_cage;
1870
1871                 /* In this case, we should never have weight-modifying modifiers in stack... */
1872                 if (do_init_statvis) {
1873                         editmesh_update_statvis_color(scene, ob);
1874                 }
1875         }
1876         else {
1877                 /* this is just a copy of the editmesh, no need to calc normals */
1878                 *r_final = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, dataMask, deformedVerts);
1879                 deformedVerts = NULL;
1880
1881                 /* In this case, we should never have weight-modifying modifiers in stack... */
1882                 if (do_init_statvis) {
1883                         editmesh_update_statvis_color(scene, ob);
1884                 }
1885         }
1886
1887         if (do_loop_normals) {
1888                 /* Compute loop normals */
1889                 BKE_mesh_calc_normals_split(*r_final);
1890                 BKE_mesh_tessface_clear(*r_final);
1891                 if (r_cage && *r_cage && (*r_cage != *r_final)) {
1892                         BKE_mesh_calc_normals_split(*r_cage);
1893                         BKE_mesh_tessface_clear(*r_cage);
1894                 }
1895         }
1896
1897         /* BMESH_ONLY, ensure tessface's used for drawing,
1898          * but don't recalculate if the last modifier in the stack gives us tessfaces
1899          * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
1900          * but quiets annoying error messages since tessfaces wont be created. */
1901         if (dataMask & CD_MASK_MFACE) {
1902                 if ((*r_final)->edit_btmesh == NULL) {
1903                         BKE_mesh_tessface_ensure(*r_final);
1904                 }
1905                 if (r_cage && *r_cage) {
1906                         if ((*r_cage)->edit_btmesh == NULL) {
1907                                 if (*r_cage != *r_final) {
1908                                         BKE_mesh_tessface_ensure(*r_cage);
1909                                 }
1910                         }
1911                 }
1912         }
1913         /* --- */
1914
1915         /* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
1916         if (!do_loop_normals) {
1917                 BKE_mesh_ensure_normals_for_display(*r_final);
1918
1919                 /* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
1920                  * as they are used by display code when available (i.e. even if autosmooth is disabled). */
1921                 if (CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
1922                         CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
1923                 }
1924                 if (r_cage && CustomData_has_layer(&(*r_cage)->ldata, CD_NORMAL)) {
1925                         CustomData_free_layers(&(*r_cage)->ldata, CD_NORMAL, (*r_cage)->totloop);
1926                 }
1927         }
1928
1929         /* add an orco layer if needed */
1930         if (dataMask & CD_MASK_ORCO)
1931                 add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
1932
1933         if (me_orco) {
1934                 BKE_id_free(NULL, me_orco);
1935         }
1936
1937         if (deformedVerts) {
1938                 MEM_freeN(deformedVerts);
1939         }
1940 }
1941
1942 static void mesh_finalize_eval(Object *object)
1943 {
1944         Mesh *mesh = (Mesh *)object->data;
1945         Mesh *mesh_eval = object->runtime.mesh_eval;
1946         /* Special Tweaks for cases when evaluated mesh came from
1947          * BKE_mesh_new_nomain_from_template().
1948          */
1949         BLI_strncpy(mesh_eval->id.name, mesh->id.name, sizeof(mesh_eval->id.name));
1950         if (mesh_eval->mat != NULL) {
1951                 MEM_freeN(mesh_eval->mat);
1952         }
1953         /* Set flag which makes it easier to see what's going on in a debugger. */
1954         mesh_eval->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT;
1955         mesh_eval->mat = MEM_dupallocN(mesh->mat);
1956         mesh_eval->totcol = mesh->totcol;
1957         /* Make evaluated mesh to share same edit mesh pointer as original
1958          * and copied meshes.
1959          */
1960         mesh_eval->edit_btmesh = mesh->edit_btmesh;
1961         /* Copy autosmooth settings from original mesh.
1962          * This is not done by BKE_mesh_new_nomain_from_template(), so need to take
1963          * extra care here.
1964          */
1965         mesh_eval->flag |= (mesh->flag & ME_AUTOSMOOTH);
1966         mesh_eval->smoothresh = mesh->smoothresh;
1967         /* Replace evaluated object's data with fully evaluated mesh. */
1968         /* TODO(sergey): There was statement done by Sybren and Mai that this
1969          * caused modifiers to be applied twice. which is weirtd and shouldn't
1970          * really happen. But since there is no reference to the report, can not
1971          * do much about this.
1972          */
1973
1974         /* Object is sometimes not evaluated!
1975          * TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
1976         if (object->id.tag & LIB_TAG_COPIED_ON_WRITE) {
1977                 object->data = mesh_eval;
1978         }
1979         else {
1980                 /* evaluated will be available via: 'object->runtime.mesh_eval' */
1981         }
1982 }
1983
1984 static void mesh_build_extra_data(struct Depsgraph *depsgraph, Object *ob)
1985 {
1986         uint32_t eval_flags = DEG_get_eval_flags_for_id(depsgraph, &ob->id);
1987
1988         if (eval_flags & DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY) {
1989                 BKE_shrinkwrap_compute_boundary_data(ob->runtime.mesh_eval);
1990         }
1991 }
1992
1993 static void mesh_runtime_check_normals_valid(const Mesh *mesh)
1994 {
1995         UNUSED_VARS_NDEBUG(mesh);
1996         BLI_assert(!(mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL));
1997         BLI_assert(!(mesh->runtime.cd_dirty_loop & CD_MASK_NORMAL));
1998         BLI_assert(!(mesh->runtime.cd_dirty_poly & CD_MASK_NORMAL));
1999 }
2000
2001 static void mesh_build_data(
2002         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask,
2003         const bool build_shapekey_layers, const bool need_mapping)
2004 {
2005         BLI_assert(ob->type == OB_MESH);
2006
2007         BKE_object_free_derived_caches(ob);
2008         BKE_object_sculpt_modifiers_changed(ob);
2009
2010         if (need_mapping) {
2011                 /* Also add the flag so that it is recorded in lastDataMask. */
2012                 dataMask |= CD_MASK_ORIGINDEX;
2013         }
2014
2015         mesh_calc_modifiers(
2016                 depsgraph, scene, ob, NULL, 1, need_mapping, dataMask, -1, true, build_shapekey_layers,
2017                 &ob->runtime.mesh_deform_eval, &ob->runtime.mesh_eval);
2018
2019 #ifdef USE_DERIVEDMESH
2020         /* TODO(campbell): remove these copies, they are expected in various places over the code. */
2021         ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, CD_MASK_MESH);
2022         ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, CD_MASK_MESH);
2023 #endif
2024
2025         BKE_object_boundbox_calc_from_mesh(ob, ob->runtime.mesh_eval);
2026         BKE_mesh_texspace_copy_from_object(ob->runtime.mesh_eval, ob);
2027
2028         mesh_finalize_eval(ob);
2029
2030 #ifdef USE_DERIVEDMESH
2031         ob->derivedFinal->needsFree = 0;
2032         ob->derivedDeform->needsFree = 0;
2033 #endif
2034         ob->lastDataMask = dataMask;
2035         ob->lastNeedMapping = need_mapping;
2036
2037         if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
2038                 /* create PBVH immediately (would be created on the fly too,
2039                  * but this avoids waiting on first stroke) */
2040                 /* XXX Disabled for now.
2041                  * This can create horrible nasty bugs by generating re-entrant call of mesh_get_eval_final! */
2042 //              BKE_sculpt_update_mesh_elements(depsgraph, scene, scene->toolsettings->sculpt, ob, false, false);
2043         }
2044
2045         mesh_runtime_check_normals_valid(ob->runtime.mesh_eval);
2046         mesh_build_extra_data(depsgraph, ob);
2047 }
2048
2049 static void editbmesh_build_data(
2050         struct Depsgraph *depsgraph, Scene *scene,
2051         Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
2052 {
2053         BKE_object_free_derived_caches(obedit);
2054         BKE_object_sculpt_modifiers_changed(obedit);
2055
2056         BKE_editmesh_free_derivedmesh(em);
2057
2058         Mesh *me_cage;
2059         Mesh *me_final;
2060
2061         editbmesh_calc_modifiers(
2062                 depsgraph, scene, obedit, em, dataMask,
2063                 &me_cage, &me_final);
2064
2065         em->mesh_eval_final = me_final;
2066         em->mesh_eval_cage = me_cage;
2067
2068         BKE_object_boundbox_calc_from_mesh(obedit, em->mesh_eval_final);
2069
2070         em->lastDataMask = dataMask;
2071
2072         mesh_runtime_check_normals_valid(em->mesh_eval_final);
2073 }
2074
2075 static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob, bool *r_need_mapping)
2076 {
2077         ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2078         Object *actob = view_layer->basact ? DEG_get_original_object(view_layer->basact->object) : NULL;
2079         CustomDataMask mask = ob->customdata_mask;
2080
2081         if (r_need_mapping) {
2082                 *r_need_mapping = false;
2083         }
2084
2085         if (DEG_get_original_object(ob) == actob) {
2086                 bool editing = BKE_paint_select_face_test(actob);
2087
2088                 /* weight paint and face select need original indices because of selection buffer drawing */
2089                 if (r_need_mapping) {
2090                         *r_need_mapping = (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT | OB_MODE_VERTEX_PAINT)));
2091                 }
2092
2093                 /* check if we need tfaces & mcols due to face select or texture paint */
2094                 if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
2095                         mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTFACE;
2096                 }
2097
2098                 /* check if we need mcols due to vertex paint or weightpaint */
2099                 if (ob->mode & OB_MODE_VERTEX_PAINT) {
2100                         mask |= CD_MASK_MLOOPCOL;
2101                 }
2102
2103                 if (ob->mode & OB_MODE_WEIGHT_PAINT) {
2104                         mask |= CD_MASK_MDEFORMVERT;
2105                 }
2106
2107                 if (ob->mode & OB_MODE_EDIT)
2108                         mask |= CD_MASK_MVERT_SKIN;
2109         }
2110
2111         return mask;
2112 }
2113
2114 void makeDerivedMesh(
2115         struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
2116         CustomDataMask dataMask, const bool build_shapekey_layers)
2117 {
2118         bool need_mapping;
2119         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2120
2121         if (em) {
2122                 editbmesh_build_data(depsgraph, scene, ob, em, dataMask);
2123         }
2124         else {
2125                 mesh_build_data(depsgraph, scene, ob, dataMask, build_shapekey_layers, need_mapping);
2126         }
2127 }
2128
2129 /***/
2130
2131 #ifdef USE_DERIVEDMESH
2132 /* Deprecated DM, use: 'mesh_get_eval_final'. */
2133 DerivedMesh *mesh_get_derived_final(
2134         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2135 {
2136         /* if there's no derived mesh or the last data mask used doesn't include
2137          * the data we need, rebuild the derived mesh
2138          */
2139         bool need_mapping;
2140         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2141
2142         if (!ob->derivedFinal ||
2143             ((dataMask & ob->lastDataMask) != dataMask) ||
2144             (need_mapping != ob->lastNeedMapping))
2145         {
2146                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2147         }
2148
2149         if (ob->derivedFinal) { BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
2150         return ob->derivedFinal;
2151 }
2152 #endif
2153 Mesh *mesh_get_eval_final(
2154         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2155 {
2156         /* Evaluation meshes on original instances aren't cleaned up properly, causing crashes. */
2157         BLI_assert(ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
2158
2159         /* if there's no evaluated mesh or the last data mask used doesn't include
2160          * the data we need, rebuild the derived mesh
2161          */
2162         bool need_mapping;
2163         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2164
2165         if (!ob->runtime.mesh_eval ||
2166             ((dataMask & ob->lastDataMask) != dataMask) ||
2167             (need_mapping && !ob->lastNeedMapping))
2168         {
2169                 mesh_build_data(depsgraph, scene, ob, dataMask | ob->lastDataMask, false, need_mapping || ob->lastNeedMapping);
2170         }
2171
2172         if (ob->runtime.mesh_eval) { BLI_assert(!(ob->runtime.mesh_eval->runtime.cd_dirty_vert & CD_MASK_NORMAL)); }
2173         return ob->runtime.mesh_eval;
2174 }
2175
2176 #ifdef USE_DERIVEDMESH
2177 /* Deprecated DM, use: 'mesh_get_eval_deform' instead. */
2178 DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2179 {
2180         /* if there's no derived mesh or the last data mask used doesn't include
2181          * the data we need, rebuild the derived mesh
2182          */
2183         bool need_mapping;
2184
2185         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2186
2187         if (!ob->derivedDeform ||
2188             ((dataMask & ob->lastDataMask) != dataMask) ||
2189             (need_mapping != ob->lastNeedMapping))
2190         {
2191                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2192         }
2193
2194         return ob->derivedDeform;
2195 }
2196 #endif
2197 Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2198 {
2199         /* if there's no derived mesh or the last data mask used doesn't include
2200          * the data we need, rebuild the derived mesh
2201          */
2202         bool need_mapping;
2203
2204         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2205
2206         if (!ob->runtime.mesh_deform_eval ||
2207             ((dataMask & ob->lastDataMask) != dataMask) ||
2208             (need_mapping != ob->lastNeedMapping))
2209         {
2210                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2211         }
2212
2213         return ob->runtime.mesh_deform_eval;
2214 }
2215
2216
2217 #ifdef USE_DERIVEDMESH
2218 /* Deprecated, use `mesh_create_eval_final_render` instead. */
2219 DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2220 {
2221         DerivedMesh *final;
2222
2223         mesh_calc_modifiers_dm(
2224                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2225                 NULL, &final);
2226
2227         return final;
2228 }
2229 #endif
2230 Mesh *mesh_create_eval_final_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2231 {
2232         Mesh *final;
2233
2234         mesh_calc_modifiers(
2235                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2236                 NULL, &final);
2237
2238         return final;
2239 }
2240
2241 #ifdef USE_DERIVEDMESH
2242 /* Deprecated, use `mesh_create_eval_final_index_render` instead. */
2243 DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask, int index)
2244 {
2245         DerivedMesh *final;
2246
2247         mesh_calc_modifiers_dm(
2248                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2249                 NULL, &final);
2250
2251         return final;
2252 }
2253 #endif
2254 Mesh *mesh_create_eval_final_index_render(
2255         struct Depsgraph *depsgraph, struct Scene *scene,
2256         struct Object *ob, CustomDataMask dataMask, int index)
2257 {
2258         Mesh *final;
2259
2260         mesh_calc_modifiers(
2261                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2262                 NULL, &final);
2263
2264         return final;
2265 }
2266
2267 #ifdef USE_DERIVEDMESH
2268 /* Deprecated, use `mesh_create_eval_final_view` instead. */
2269 DerivedMesh *mesh_create_derived_view(
2270         struct Depsgraph *depsgraph, Scene *scene,
2271         Object *ob, CustomDataMask dataMask)
2272 {
2273         DerivedMesh *final;
2274
2275         /* XXX hack
2276          * psys modifier updates particle state when called during dupli-list generation,
2277          * which can lead to wrong transforms. This disables particle system modifier execution.
2278          */
2279         ob->transflag |= OB_NO_PSYS_UPDATE;
2280
2281         mesh_calc_modifiers_dm(
2282                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2283                 NULL, &final);
2284
2285         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2286
2287         return final;
2288 }
2289 #endif
2290
2291 Mesh *mesh_create_eval_final_view(
2292         struct Depsgraph *depsgraph, Scene *scene,
2293         Object *ob, CustomDataMask dataMask)
2294 {
2295         Mesh *final;
2296
2297         /* XXX hack
2298          * psys modifier updates particle state when called during dupli-list generation,
2299          * which can lead to wrong transforms. This disables particle system modifier execution.
2300          */
2301         ob->transflag |= OB_NO_PSYS_UPDATE;
2302
2303         mesh_calc_modifiers(
2304                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2305                 NULL, &final);
2306
2307         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2308
2309         return final;
2310 }
2311
2312 DerivedMesh *mesh_create_derived_no_deform(
2313         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
2314         float (*vertCos)[3], CustomDataMask dataMask)
2315 {
2316         DerivedMesh *final;
2317
2318         mesh_calc_modifiers_dm(
2319                 depsgraph, scene, ob, vertCos, 0, false, dataMask, -1, false, false,
2320                 NULL, &final);
2321
2322         return final;
2323 }
2324
2325 /***/
2326
2327 Mesh *editbmesh_get_eval_cage_and_final(
2328         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2329         CustomDataMask dataMask,
2330         /* return args */
2331         Mesh **r_final)
2332 {
2333         /* if there's no derived mesh or the last data mask used doesn't include
2334          * the data we need, rebuild the derived mesh
2335          */
2336         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2337
2338         if (!em->mesh_eval_cage ||
2339             (em->lastDataMask & dataMask) != dataMask)
2340         {
2341                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2342         }
2343
2344         *r_final = em->mesh_eval_final;
2345         if (em->mesh_eval_final) { BLI_assert(!(em->mesh_eval_final->runtime.cd_dirty_vert & DM_DIRTY_NORMALS)); }
2346         return em->mesh_eval_cage;
2347 }
2348
2349 Mesh *editbmesh_get_eval_cage(
2350         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2351         CustomDataMask dataMask)
2352 {
2353         /* if there's no derived mesh or the last data mask used doesn't include
2354          * the data we need, rebuild the derived mesh
2355          */
2356         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2357
2358         if (!em->mesh_eval_cage ||
2359             (em->lastDataMask & dataMask) != dataMask)
2360         {
2361                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2362         }
2363
2364         return em->mesh_eval_cage;
2365 }
2366
2367 /***/
2368
2369 /* UNUSED */
2370 #if 0
2371
2372 /* ********* For those who don't grasp derived stuff! (ton) :) *************** */
2373
2374 static void make_vertexcosnos__mapFunc(void *userData, int index, const float co[3],
2375                                        const float no_f[3], const short no_s[3])
2376 {
2377         DMCoNo *co_no = &((DMCoNo *)userData)[index];
2378
2379         /* check if we've been here before (normal should not be 0) */
2380         if (!is_zero_v3(co_no->no)) {
2381                 return;
2382         }
2383
2384         copy_v3_v3(co_no->co, co);
2385         if (no_f) {
2386                 copy_v3_v3(co_no->no, no_f);
2387         }
2388         else {
2389                 normal_short_to_float_v3(co_no->no, no_s);
2390         }
2391 }
2392
2393 /* always returns original amount me->totvert of vertices and normals, but fully deformed and subsurfered */
2394 /* this is needed for all code using vertexgroups (no subsurf support) */
2395 /* it stores the normals as floats, but they can still be scaled as shorts (32767 = unit) */
2396 /* in use now by vertex/weight paint and particle generating */
2397
2398 DMCoNo *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
2399 {
2400         Mesh *me = ob->data;
2401         DerivedMesh *dm;
2402         DMCoNo *vertexcosnos;
2403
2404         /* lets prevent crashing... */
2405         if (ob->type != OB_MESH || me->totvert == 0)
2406                 return NULL;
2407
2408         dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
2409
2410         if (dm->foreachMappedVert) {
2411                 vertexcosnos = MEM_calloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2412                 dm->foreachMappedVert(dm, make_vertexcosnos__mapFunc, vertexcosnos);
2413         }
2414         else {
2415                 DMCoNo *v_co_no = vertexcosnos = MEM_malloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2416                 int a;
2417                 for (a = 0; a < me->totvert; a++, v_co_no++) {
2418                         dm->getVertCo(dm, a, v_co_no->co);
2419                         dm->getVertNo(dm, a, v_co_no->no);
2420                 }
2421         }
2422
2423         dm->release(dm);
2424         return vertexcosnos;
2425 }
2426
2427 #endif
2428
2429 /* same as above but for vert coords */
2430 typedef struct {
2431         float (*vertexcos)[3];
2432         BLI_bitmap *vertex_visit;
2433 } MappedUserData;
2434
2435 static void make_vertexcos__mapFunc(
2436         void *userData, int index, const float co[3],
2437         const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
2438 {
2439         MappedUserData *mappedData = (MappedUserData *)userData;
2440
2441         if (BLI_BITMAP_TEST(mappedData->vertex_visit, index) == 0) {
2442                 /* we need coord from prototype vertex, not from copies,
2443                  * assume they stored in the beginning of vertex array stored in DM
2444                  * (mirror modifier for eg does this) */
2445                 copy_v3_v3(mappedData->vertexcos[index], co);
2446                 BLI_BITMAP_ENABLE(mappedData->vertex_visit, index);
2447         }
2448 }
2449
2450 void mesh_get_mapped_verts_coords(Mesh *me_eval, float (*r_cos)[3], const int totcos)
2451 {
2452         if (me_eval->runtime.deformed_only == false) {
2453                 MappedUserData userData;
2454                 memset(r_cos, 0, sizeof(*r_cos) * totcos);
2455                 userData.vertexcos = r_cos;
2456                 userData.vertex_visit = BLI_BITMAP_NEW(totcos, "vertexcos flags");
2457                 BKE_mesh_foreach_mapped_vert(me_eval, make_vertexcos__mapFunc, &userData, MESH_FOREACH_NOP);
2458                 MEM_freeN(userData.vertex_visit);
2459         }
2460         else {
2461                 MVert *mv = me_eval->mvert;
2462                 for (int i = 0; i < totcos; i++, mv++) {
2463                         copy_v3_v3(r_cos[i], mv->co);
2464                 }
2465         }
2466 }
2467
2468 void DM_add_named_tangent_layer_for_uv(
2469         CustomData *uv_data, CustomData *tan_data, int numLoopData,
2470         const char *layer_name)
2471 {
2472         if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
2473             CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
2474         {
2475                 CustomData_add_layer_named(
2476                         tan_data, CD_TANGENT, CD_CALLOC, NULL,
2477                         numLoopData, layer_name);
2478         }
2479 }
2480
2481 void DM_calc_loop_tangents(
2482         DerivedMesh *dm, bool calc_active_tangent,
2483         const char (*tangent_names)[MAX_NAME], int tangent_names_len)
2484 {
2485         BKE_mesh_calc_loop_tangent_ex(
2486                 dm->getVertArray(dm),
2487                 dm->getPolyArray(dm), dm->getNumPolys(dm),
2488                 dm->getLoopArray(dm),
2489                 dm->getLoopTriArray(dm), dm->getNumLoopTri(dm),
2490                 &dm->loopData,
2491                 calc_active_tangent,
2492                 tangent_names, tangent_names_len,
2493                 CustomData_get_layer(&dm->polyData, CD_NORMAL),
2494                 dm->getLoopDataArray(dm, CD_NORMAL),
2495                 dm->getVertDataArray(dm, CD_ORCO),  /* may be NULL */
2496                 /* result */
2497                 &dm->loopData, dm->getNumLoops(dm),
2498                 &dm->tangent_mask);
2499 }
2500
2501 void DM_init_origspace(DerivedMesh *dm)
2502 {
2503         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2504
2505         OrigSpaceLoop *lof_array = CustomData_get_layer(&dm->loopData, CD_ORIGSPACE_MLOOP);
2506         const int numpoly = dm->getNumPolys(dm);
2507         // const int numloop = dm->getNumLoops(dm);
2508         MVert *mv = dm->getVertArray(dm);
2509         MLoop *ml = dm->getLoopArray(dm);
2510         MPoly *mp = dm->getPolyArray(dm);
2511         int i, j, k;
2512
2513         float (*vcos_2d)[2] = NULL;
2514         BLI_array_staticdeclare(vcos_2d, 64);
2515
2516         for (i = 0; i < numpoly; i++, mp++) {
2517                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2518
2519                 if (mp->totloop == 3 || mp->totloop == 4) {
2520                         for (j = 0; j < mp->totloop; j++, lof++) {
2521                                 copy_v2_v2(lof->uv, default_osf[j]);
2522                         }
2523                 }
2524                 else {
2525                         MLoop *l = &ml[mp->loopstart];
2526                         float p_nor[3], co[3];
2527                         float mat[3][3];
2528
2529                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2530                         float translate[2], scale[2];
2531
2532                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2533                         axis_dominant_v3_to_m3(mat, p_nor);
2534
2535                         BLI_array_clear(vcos_2d);
2536                         BLI_array_reserve(vcos_2d, mp->totloop);
2537                         for (j = 0; j < mp->totloop; j++, l++) {
2538                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2539                                 copy_v2_v2(vcos_2d[j], co);
2540
2541                                 for (k = 0; k < 2; k++) {
2542                                         if (co[k] > max[k])
2543                                                 max[k] = co[k];
2544                                         else if (co[k] < min[k])
2545                                                 min[k] = co[k];
2546                                 }
2547                         }
2548
2549                         /* Brings min to (0, 0). */
2550                         negate_v2_v2(translate, min);
2551
2552                         /* Scale will bring max to (1, 1). */
2553                         sub_v2_v2v2(scale, max, min);
2554                         if (scale[0] == 0.0f)
2555                                 scale[0] = 1e-9f;
2556                         if (scale[1] == 0.0f)
2557                                 scale[1] = 1e-9f;
2558                         invert_v2(scale);
2559
2560                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2561                         for (j = 0; j < mp->totloop; j++, lof++) {
2562                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2563                                 mul_v2_v2(lof->uv, scale);
2564                         }
2565                 }
2566         }
2567
2568         dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
2569         BLI_array_free(vcos_2d);
2570 }
2571
2572 static void mesh_init_origspace(Mesh *mesh)
2573 {
2574         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2575
2576         OrigSpaceLoop *lof_array = CustomData_get_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP);
2577         const int numpoly = mesh->totpoly;
2578         // const int numloop = mesh->totloop;
2579         MVert *mv = mesh->mvert;
2580         MLoop *ml = mesh->mloop;
2581         MPoly *mp = mesh->mpoly;
2582         int i, j, k;
2583
2584         float (*vcos_2d)[2] = NULL;
2585         BLI_array_staticdeclare(vcos_2d, 64);
2586
2587         for (i = 0; i < numpoly; i++, mp++) {
2588                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2589
2590                 if (mp->totloop == 3 || mp->totloop == 4) {
2591                         for (j = 0; j < mp->totloop; j++, lof++) {
2592                                 copy_v2_v2(lof->uv, default_osf[j]);
2593                         }
2594                 }
2595                 else {
2596                         MLoop *l = &ml[mp->loopstart];
2597                         float p_nor[3], co[3];
2598                         float mat[3][3];
2599
2600                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2601                         float translate[2], scale[2];
2602
2603                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2604                         axis_dominant_v3_to_m3(mat, p_nor);
2605
2606                         BLI_array_clear(vcos_2d);
2607                         BLI_array_reserve(vcos_2d, mp->totloop);
2608                         for (j = 0; j < mp->totloop; j++, l++) {
2609                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2610                                 copy_v2_v2(vcos_2d[j], co);
2611
2612                                 for (k = 0; k < 2; k++) {
2613                                         if (co[k] > max[k])
2614                                                 max[k] = co[k];
2615                                         else if (co[k] < min[k])
2616                                                 min[k] = co[k];
2617                                 }
2618                         }
2619
2620                         /* Brings min to (0, 0). */
2621                         negate_v2_v2(translate, min);
2622
2623                         /* Scale will bring max to (1, 1). */
2624                         sub_v2_v2v2(scale, max, min);
2625                         if (scale[0] == 0.0f)
2626                                 scale[0] = 1e-9f;
2627                         if (scale[1] == 0.0f)
2628                                 scale[1] = 1e-9f;
2629                         invert_v2(scale);
2630
2631                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2632                         for (j = 0; j < mp->totloop; j++, lof++) {
2633                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2634                                 mul_v2_v2(lof->uv, scale);
2635                         }
2636                 }
2637         }
2638
2639         BKE_mesh_tessface_clear(mesh);
2640         BLI_array_free(vcos_2d);
2641 }
2642
2643
2644 /* derivedmesh info printing function,
2645  * to help track down differences DM output */
2646
2647 #ifndef NDEBUG
2648 #include "BLI_dynstr.h"
2649
2650 static void dm_debug_info_layers(
2651         DynStr *dynstr, DerivedMesh *dm, CustomData *cd,
2652         void *(*getElemDataArray)(DerivedMesh *, int))
2653 {
2654         int type;
2655
2656         for (type = 0; type < CD_NUMTYPES; type++) {
2657                 if (CustomData_has_layer(cd, type)) {
2658                         /* note: doesn't account for multiple layers */
2659                         const char *name = CustomData_layertype_name(type);
2660                         const int size = CustomData_sizeof(type);
2661                         const void *pt = getElemDataArray(dm, type);
2662                         const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
2663                         const char *structname;
2664                         int structnum;
2665                         CustomData_file_write_info(type, &structname, &structnum);
2666                         BLI_dynstr_appendf(dynstr,
2667                                            "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2668                                            name, structname, type, (const void *)pt, size, pt_size);
2669                 }
2670         }
2671 }
2672
2673 char *DM_debug_info(DerivedMesh *dm)
2674 {
2675         DynStr *dynstr = BLI_dynstr_new();
2676         char *ret;
2677         const char *tstr;
2678
2679         BLI_dynstr_appendf(dynstr, "{\n");
2680         BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)dm);
2681         switch (dm->type) {
2682                 case DM_TYPE_CDDM:     tstr = "DM_TYPE_CDDM";     break;
2683                 case DM_TYPE_CCGDM:    tstr = "DM_TYPE_CCGDM";     break;
2684                 default:               tstr = "UNKNOWN";           break;
2685         }
2686         BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
2687         BLI_dynstr_appendf(dynstr, "    'numVertData': %d,\n", dm->numVertData);
2688         BLI_dynstr_appendf(dynstr, "    'numEdgeData': %d,\n", dm->numEdgeData);
2689         BLI_dynstr_appendf(dynstr, "    'numTessFaceData': %d,\n", dm->numTessFaceData);
2690         BLI_dynstr_appendf(dynstr, "    'numPolyData': %d,\n", dm->numPolyData);
2691         BLI_dynstr_appendf(dynstr, "    'deformedOnly': %d,\n", dm->deformedOnly);
2692
2693         BLI_dynstr_appendf(dynstr, "    'vertexLayers': (\n");
2694         dm_debug_info_layers(dynstr, dm, &dm->vertData, dm->getVertDataArray);
2695         BLI_dynstr_appendf(dynstr, "    ),\n");
2696
2697         BLI_dynstr_appendf(dynstr, "    'edgeLayers': (\n");
2698         dm_debug_info_layers(dynstr, dm, &dm->edgeData, dm->getEdgeDataArray);
2699         BLI_dynstr_appendf(dynstr, "    ),\n");
2700
2701         BLI_dynstr_appendf(dynstr, "    'loopLayers': (\n");
2702         dm_debug_info_layers(dynstr, dm, &dm->loopData, dm->getLoopDataArray);
2703         BLI_dynstr_appendf(dynstr, "    ),\n");
2704
2705         BLI_dynstr_appendf(dynstr, "    'polyLayers': (\n");
2706         dm_debug_info_layers(dynstr, dm, &dm->polyData, dm->getPolyDataArray);
2707         BLI_dynstr_appendf(dynstr, "    ),\n");
2708
2709         BLI_dynstr_appendf(dynstr, "    'tessFaceLayers': (\n");
2710         dm_debug_info_layers(dynstr, dm, &dm->faceData, dm->getTessFaceDataArray);
2711         BLI_dynstr_appendf(dynstr, "    ),\n");
2712
2713         BLI_dynstr_appendf(dynstr, "}\n");
2714
2715         ret = BLI_dynstr_get_cstring(dynstr);
2716         BLI_dynstr_free(dynstr);
2717         return ret;
2718 }
2719
2720 void DM_debug_print(DerivedMesh *dm)
2721 {
2722         char *str = DM_debug_info(dm);
2723         puts(str);
2724         fflush(stdout);
2725         MEM_freeN(str);
2726 }
2727
2728 void DM_debug_print_cdlayers(CustomData *data)
2729 {
2730         int i;
2731         const CustomDataLayer *layer;
2732
2733         printf("{\n");
2734
2735         for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
2736
2737                 const char *name = CustomData_layertype_name(layer->type);
2738                 const int size = CustomData_sizeof(layer->type);
2739                 const char *structname;
2740                 int structnum;
2741                 CustomData_file_write_info(layer->type, &structname, &structnum);
2742                 printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2743                        name, structname, layer->type, (const void *)layer->data, size, (int)(MEM_allocN_len(layer->data) / size));
2744         }
2745
2746         printf("}\n");
2747 }
2748
2749 bool DM_is_valid(DerivedMesh *dm)
2750 {
2751         const bool do_verbose = true;
2752         const bool do_fixes = false;
2753
2754         bool is_valid = true;
2755         bool changed = true;
2756
2757         is_valid &= BKE_mesh_validate_all_customdata(
2758                 dm->getVertDataLayout(dm),
2759                 dm->getEdgeDataLayout(dm),
2760                 dm->getLoopDataLayout(dm),
2761                 dm->getPolyDataLayout(dm),
2762                 false,  /* setting mask here isn't useful, gives false positives */
2763                 do_verbose, do_fixes, &changed);
2764
2765         is_valid &= BKE_mesh_validate_arrays(
2766                 NULL,
2767                 dm->getVertArray(dm), dm->getNumVerts(dm),
2768                 dm->getEdgeArray(dm), dm->getNumEdges(dm),
2769                 dm->getTessFaceArray(dm), dm->getNumTessFaces(dm),
2770                 dm->getLoopArray(dm), dm->getNumLoops(dm),
2771                 dm->getPolyArray(dm), dm->getNumPolys(dm),
2772                 dm->getVertDataArray(dm, CD_MDEFORMVERT),
2773                 do_verbose, do_fixes, &changed);
2774
2775         BLI_assert(changed == false);
2776
2777         return is_valid;
2778 }
2779
2780 #endif /* NDEBUG */