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