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