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