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