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