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