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