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