208803a8de94afcf8c2d7a49a63b149af5bf0444
[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
1918 /* TODO(campbell): support mesh with only an edit-mesh which is lazy initialized. */
1919 static Mesh *mesh_from_editmesh_with_coords(
1920         BMEditMesh *em, CustomDataMask data_mask, float (*vertexCos)[3])
1921 {
1922         Mesh *me = BKE_bmesh_to_mesh_nomain(
1923                 em->bm,
1924                 &(struct BMeshToMeshParams){
1925                     .cd_mask_extra = data_mask,
1926                 });
1927         if (vertexCos) {
1928                 /* We will own this array in the future. */
1929                 BKE_mesh_apply_vert_coords(me, vertexCos);
1930                 MEM_freeN(vertexCos);
1931         }
1932         return me;
1933 }
1934
1935 static void editbmesh_calc_modifiers(
1936         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
1937         BMEditMesh *em, CustomDataMask dataMask,
1938         /* return args */
1939         Mesh **r_cage, Mesh **r_final)
1940 {
1941         ModifierData *md;
1942         float (*deformedVerts)[3] = NULL;
1943         CustomDataMask mask = 0, append_mask = 0;
1944         Mesh *me = NULL;
1945         Mesh *me_orco = NULL;
1946         int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
1947         CDMaskLink *datamasks, *curr;
1948         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1949
1950 #if 0
1951         const bool do_init_statvis = false;
1952 #endif
1953         VirtualModifierData virtualModifierData;
1954
1955         /* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
1956         const ModifierEvalContext mectx = {depsgraph, ob, 0};
1957         const ModifierEvalContext mectx_orco = {depsgraph, ob, MOD_APPLY_ORCO};
1958         const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE};
1959
1960         const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
1961
1962         modifiers_clearErrors(ob);
1963
1964         if (r_cage && cageIndex == -1) {
1965                 *r_cage = mesh_from_editmesh_with_coords(em, dataMask, NULL);
1966         }
1967
1968         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1969
1970         /* copied from mesh_calc_modifiers */
1971         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
1972
1973         curr = datamasks;
1974         for (i = 0; md; i++, md = md->next, curr = curr->next) {
1975                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1976
1977                 if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
1978                         continue;
1979                 }
1980
1981                 /* add an orco layer if needed by this modifier */
1982                 if (me && mti->requiredDataMask) {
1983                         mask = mti->requiredDataMask(ob, md);
1984                         if (mask & CD_MASK_ORCO) {
1985                                 add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
1986                         }
1987                 }
1988
1989                 /* How to apply modifier depends on (a) what we already have as
1990                  * a result of previous modifiers (could be a DerivedMesh or just
1991                  * deformed vertices) and (b) what type the modifier is.
1992                  */
1993
1994                 if (mti->type == eModifierTypeType_OnlyDeform) {
1995                         /* No existing verts to deform, need to build them. */
1996                         if (!deformedVerts) {
1997                                 if (me) {
1998                                         /* Deforming a derived mesh, read the vertex locations
1999                                          * out of the mesh and deform them. Once done with this
2000                                          * run of deformers verts will be written back.
2001                                          */
2002                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
2003                                 }
2004                                 else {
2005                                         deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
2006                                 }
2007                         }
2008
2009                         if (mti->deformVertsEM)
2010                                 modwrap_deformVertsEM(md, &mectx, em, me, deformedVerts, numVerts);
2011                         else
2012                                 modwrap_deformVerts(md, &mectx, me, deformedVerts, numVerts);
2013                 }
2014                 else {
2015                         Mesh *me_next;
2016
2017                         /* apply vertex coordinates or build a DerivedMesh as necessary */
2018                         if (me) {
2019                                 if (deformedVerts) {
2020                                         Mesh *me_temp = BKE_mesh_copy_for_eval(me, false);
2021
2022                                         if (!(r_cage && me == *r_cage)) {
2023                                                 BKE_id_free(NULL, me);
2024                                         }
2025                                         me = me_temp;
2026                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
2027                                 }
2028                                 else if (r_cage && me == *r_cage) {
2029                                         /* 'me' may be changed by this modifier, so we need to copy it. */
2030                                         me = BKE_mesh_copy_for_eval(me, false);
2031                                 }
2032
2033                         }
2034                         else {
2035                                 me = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
2036                                 ASSERT_IS_VALID_MESH(me);
2037
2038                                 if (deformedVerts) {
2039                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
2040                                 }
2041                         }
2042
2043                         /* create an orco derivedmesh in parallel */
2044                         mask = curr->mask;
2045                         if (mask & CD_MASK_ORCO) {
2046                                 if (!me_orco) {
2047                                         me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
2048                                 }
2049
2050                                 mask &= ~CD_MASK_ORCO;
2051                                 mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
2052
2053                                 if (mti->applyModifierEM) {
2054                                         me_next = modwrap_applyModifierEM(md, &mectx_orco, em, me_orco);
2055                                 }
2056                                 else {
2057                                         me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
2058                                 }
2059                                 ASSERT_IS_VALID_MESH(me_next);
2060
2061                                 if (me_next) {
2062                                         /* if the modifier returned a new dm, release the old one */
2063                                         if (me_orco && me_orco != me_next) {
2064                                                 BKE_id_free(NULL, me_orco);
2065                                         }
2066                                         me_orco = me_next;
2067                                 }
2068                         }
2069
2070                         /* set the DerivedMesh to only copy needed data */
2071                         mask |= append_mask;
2072                         mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
2073
2074                         mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
2075
2076                         if (mask & CD_MASK_ORIGSPACE_MLOOP) {
2077                                 if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
2078                                         CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
2079                                         mesh_init_origspace(me);
2080                                 }
2081                         }
2082
2083                         if (mti->applyModifierEM) {
2084                                 me_next = modwrap_applyModifierEM(md, &mectx_cache, em, me);
2085                         }
2086                         else {
2087                                 me_next = modwrap_applyModifier(md, &mectx_cache, me);
2088                         }
2089                         ASSERT_IS_VALID_MESH(me_next);
2090
2091                         if (me_next) {
2092                                 if (me && me != me_next) {
2093                                         BKE_id_free(NULL, me);
2094                                 }
2095                                 me = me_next;
2096
2097                                 if (deformedVerts) {
2098                                         MEM_freeN(deformedVerts);
2099                                         deformedVerts = NULL;
2100                                 }
2101                         }
2102                         me->runtime.deformed_only = false;
2103                 }
2104
2105                 if (r_cage && i == cageIndex) {
2106                         if (me && deformedVerts) {
2107                                 *r_cage = BKE_mesh_copy_for_eval(me, false);
2108                                 BKE_mesh_apply_vert_coords(*r_cage, deformedVerts);
2109                         }
2110                         else if (me) {
2111                                 *r_cage = me;
2112                         }
2113                         else {
2114                                 struct Mesh *me_orig = ob->data;
2115                                 if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2116                                         BKE_mesh_runtime_ensure_edit_data(me_orig);
2117                                         me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
2118                                 }
2119                                 *r_cage = mesh_from_editmesh_with_coords(
2120                                         em, mask,
2121                                         deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
2122                         }
2123                 }
2124         }
2125
2126         BLI_linklist_free((LinkNode *)datamasks, NULL);
2127
2128         /* Yay, we are done. If we have a DerivedMesh and deformed vertices need
2129          * to apply these back onto the DerivedMesh. If we have no DerivedMesh
2130          * then we need to build one.
2131          */
2132         if (me && deformedVerts) {
2133                 *r_final = BKE_mesh_copy_for_eval(me, false);
2134
2135                 if (!(r_cage && me == *r_cage)) {
2136                         BKE_id_free(NULL, me);
2137                 }
2138                 BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
2139         }
2140         else if (me) {
2141                 *r_final = me;
2142         }
2143         else if (!deformedVerts && r_cage && *r_cage) {
2144                 /* cage should already have up to date normals */
2145                 *r_final = *r_cage;
2146
2147 #if 0
2148                 /* In this case, we should never have weight-modifying modifiers in stack... */
2149                 if (do_init_statvis) {
2150                         DM_update_statvis_color(scene, ob, *r_final);
2151                 }
2152 #endif
2153         }
2154         else {
2155                 /* this is just a copy of the editmesh, no need to calc normals */
2156                 struct Mesh *mesh = ob->data;
2157                 if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2158                         BKE_mesh_runtime_ensure_edit_data(mesh);
2159                         if (mesh->runtime.edit_data->vertexCos != NULL)
2160                                 MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
2161                         mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
2162                 }
2163                 *r_final = mesh_from_editmesh_with_coords(em, dataMask, deformedVerts);
2164                 deformedVerts = NULL;
2165
2166 #if 0
2167                 /* In this case, we should never have weight-modifying modifiers in stack... */
2168                 if (do_init_statvis) {
2169                         DM_update_statvis_color(scene, ob, *r_final);
2170                 }
2171 #endif
2172         }
2173
2174         if (do_loop_normals) {
2175                 /* Compute loop normals */
2176                 BKE_mesh_calc_normals_split(*r_final);
2177                 BKE_mesh_tessface_clear(*r_final);
2178                 if (r_cage && *r_cage && (*r_cage != *r_final)) {
2179                         BKE_mesh_calc_normals_split(*r_cage);
2180                         BKE_mesh_tessface_clear(*r_cage);
2181                 }
2182         }
2183
2184         /* BMESH_ONLY, ensure tessface's used for drawing,
2185          * but don't recalculate if the last modifier in the stack gives us tessfaces
2186          * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
2187          * but quiets annoying error messages since tessfaces wont be created. */
2188         if (dataMask & CD_MASK_MFACE) {
2189                 if ((*r_final)->edit_btmesh == NULL) {
2190                         BKE_mesh_tessface_ensure(*r_final);
2191                 }
2192                 if (r_cage && *r_cage) {
2193                         if ((*r_cage)->edit_btmesh == NULL) {
2194                                 if (*r_cage != *r_final) {
2195                                         BKE_mesh_tessface_ensure(*r_cage);
2196                                 }
2197                         }
2198                 }
2199         }
2200         /* --- */
2201
2202         /* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
2203         if (!do_loop_normals) {
2204                 mesh_ensure_display_normals(*r_final);
2205
2206                 /* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
2207                  * as they are used by display code when available (i.e. even if autosmooth is disabled). */
2208                 if (CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
2209                         CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
2210                 }
2211                 if (r_cage && CustomData_has_layer(&(*r_cage)->ldata, CD_NORMAL)) {
2212                         CustomData_free_layers(&(*r_cage)->ldata, CD_NORMAL, (*r_cage)->totloop);
2213                 }
2214         }
2215
2216         /* add an orco layer if needed */
2217         if (dataMask & CD_MASK_ORCO)
2218                 add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
2219
2220         if (me_orco) {
2221                 BKE_id_free(NULL, me_orco);
2222         }
2223
2224         if (deformedVerts) {
2225                 MEM_freeN(deformedVerts);
2226         }
2227 }
2228
2229 static void mesh_finalize_eval(Object *object)
2230 {
2231         Mesh *mesh = (Mesh *)object->data;
2232         Mesh *mesh_eval = object->runtime.mesh_eval;
2233         /* Special Tweaks for cases when evaluated mesh came from
2234          * BKE_mesh_new_nomain_from_template().
2235          */
2236         BLI_strncpy(mesh_eval->id.name, mesh->id.name, sizeof(mesh_eval->id.name));
2237         if (mesh_eval->mat != NULL) {
2238                 MEM_freeN(mesh_eval->mat);
2239         }
2240         /* Set flag which makes it easier to see what's going on in a debugger. */
2241         mesh_eval->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT;
2242         mesh_eval->mat = MEM_dupallocN(mesh->mat);
2243         mesh_eval->totcol = mesh->totcol;
2244         /* Make evaluated mesh to share same edit mesh pointer as original
2245          * and copied meshes.
2246          */
2247         mesh_eval->edit_btmesh = mesh->edit_btmesh;
2248         /* Copy autosmooth settings from original mesh.
2249          * This is not done by BKE_mesh_new_nomain_from_template(), so need to take
2250          * extra care here.
2251          */
2252         mesh_eval->flag |= (mesh->flag & ME_AUTOSMOOTH);
2253         mesh_eval->smoothresh = mesh->smoothresh;
2254         /* Replace evaluated object's data with fully evaluated mesh. */
2255         /* TODO(sergey): There was statement done by Sybren and Mai that this
2256          * caused modifiers to be applied twice. which is weirtd and shouldn't
2257          * really happen. But since there is no reference to the report, can not
2258          * do much about this.
2259          */
2260
2261         /* Object is sometimes not evaluated!
2262          * TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
2263         if (object->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2264                 object->data = mesh_eval;
2265         }
2266         else {
2267                 /* evaluated will be available via: 'object->runtime.mesh_eval' */
2268         }
2269 }
2270
2271 static void mesh_build_data(
2272         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask,
2273         const bool build_shapekey_layers, const bool need_mapping)
2274 {
2275         BLI_assert(ob->type == OB_MESH);
2276
2277         BKE_object_free_derived_caches(ob);
2278         BKE_object_sculpt_modifiers_changed(ob);
2279
2280         mesh_calc_modifiers(
2281                 depsgraph, scene, ob, NULL, 1, need_mapping, dataMask, -1, true, build_shapekey_layers,
2282                 &ob->runtime.mesh_deform_eval, &ob->runtime.mesh_eval);
2283
2284         mesh_finalize_eval(ob);
2285
2286         ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, CD_MASK_MESH);
2287         ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, CD_MASK_MESH);
2288
2289         DM_set_object_boundbox(ob, ob->derivedFinal);
2290         /* TODO(sergey): Convert bounding box calculation to use mesh, then
2291          * we can skip this copy.
2292          */
2293         BKE_mesh_texspace_copy_from_object(ob->runtime.mesh_eval, ob);
2294
2295         ob->derivedFinal->needsFree = 0;
2296         ob->derivedDeform->needsFree = 0;
2297         ob->lastDataMask = dataMask;
2298         ob->lastNeedMapping = need_mapping;
2299
2300         if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
2301                 /* create PBVH immediately (would be created on the fly too,
2302                  * but this avoids waiting on first stroke) */
2303                 /* XXX Disabled for now.
2304                  * This can create horrible nasty bugs by generating re-entrant call of mesh_get_eval_final! */
2305 //              BKE_sculpt_update_mesh_elements(depsgraph, scene, scene->toolsettings->sculpt, ob, false, false);
2306         }
2307
2308         BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS));
2309 }
2310
2311 static void editbmesh_build_data(
2312         struct Depsgraph *depsgraph, Scene *scene,
2313         Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
2314 {
2315         BKE_object_free_derived_caches(obedit);
2316         BKE_object_sculpt_modifiers_changed(obedit);
2317
2318         BKE_editmesh_free_derivedmesh(em);
2319
2320         Mesh *me_cage;
2321         Mesh *me_final;
2322
2323         editbmesh_calc_modifiers(
2324                 depsgraph, scene, obedit, em, dataMask,
2325                 &me_cage, &me_final);
2326
2327         /* TODO(campbell): remove derived mesh conversion. */
2328         em->derivedFinal = CDDM_from_mesh_ex(me_final, CD_DUPLICATE, CD_MASK_MESH);
2329         BKE_id_free(NULL, me_final);
2330         if (me_cage != me_final) {
2331                 em->derivedCage = CDDM_from_mesh_ex(me_cage, CD_DUPLICATE, CD_MASK_MESH);
2332                 BKE_id_free(NULL, me_cage);
2333         }
2334         else {
2335                 em->derivedCage = em->derivedFinal;
2336         }
2337
2338         DM_set_object_boundbox(obedit, em->derivedFinal);
2339
2340         em->lastDataMask = dataMask;
2341         em->derivedFinal->needsFree = 0;
2342         em->derivedCage->needsFree = 0;
2343
2344         BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS));
2345 }
2346
2347 static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob, bool *r_need_mapping)
2348 {
2349         ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2350         Object *actob = view_layer->basact ? DEG_get_original_object(view_layer->basact->object) : NULL;
2351         CustomDataMask mask = ob->customdata_mask;
2352
2353         if (r_need_mapping) {
2354                 *r_need_mapping = false;
2355         }
2356
2357         if (DEG_get_original_object(ob) == actob) {
2358                 bool editing = BKE_paint_select_face_test(ob);
2359
2360                 /* weight paint and face select need original indices because of selection buffer drawing */
2361                 if (r_need_mapping) {
2362                         *r_need_mapping = (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT | OB_MODE_VERTEX_PAINT)));
2363                 }
2364
2365                 /* check if we need tfaces & mcols due to face select or texture paint */
2366                 if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
2367                         mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
2368                 }
2369
2370                 /* check if we need mcols due to vertex paint or weightpaint */
2371                 if (ob->mode & OB_MODE_VERTEX_PAINT) {
2372                         mask |= CD_MASK_MLOOPCOL;
2373                 }
2374
2375                 if (ob->mode & OB_MODE_EDIT)
2376                         mask |= CD_MASK_MVERT_SKIN;
2377         }
2378
2379         return mask;
2380 }
2381
2382 void makeDerivedMesh(
2383         struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
2384         CustomDataMask dataMask, const bool build_shapekey_layers)
2385 {
2386         bool need_mapping;
2387         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2388
2389         if (em) {
2390                 editbmesh_build_data(depsgraph, scene, ob, em, dataMask);
2391         }
2392         else {
2393                 mesh_build_data(depsgraph, scene, ob, dataMask, build_shapekey_layers, need_mapping);
2394         }
2395 }
2396
2397 /***/
2398
2399 #ifdef USE_DERIVEDMESH
2400 /* Deprecated DM, use: 'mesh_get_eval_final'. */
2401 DerivedMesh *mesh_get_derived_final(
2402         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2403 {
2404         /* if there's no derived mesh or the last data mask used doesn't include
2405          * the data we need, rebuild the derived mesh
2406          */
2407         bool need_mapping;
2408         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2409
2410         if (!ob->derivedFinal ||
2411             ((dataMask & ob->lastDataMask) != dataMask) ||
2412             (need_mapping != ob->lastNeedMapping))
2413         {
2414                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2415         }
2416
2417         if (ob->derivedFinal) { BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
2418         return ob->derivedFinal;
2419 }
2420 #endif
2421 Mesh *mesh_get_eval_final(
2422         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2423 {
2424         /* if there's no evaluated mesh or the last data mask used doesn't include
2425          * the data we need, rebuild the derived mesh
2426          */
2427         bool need_mapping;
2428         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2429
2430         if (!ob->runtime.mesh_eval ||
2431             ((dataMask & ob->lastDataMask) != dataMask) ||
2432             (need_mapping != ob->lastNeedMapping))
2433         {
2434                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2435         }
2436
2437         if (ob->runtime.mesh_eval) { BLI_assert(!(ob->runtime.mesh_eval->runtime.cd_dirty_vert & CD_MASK_NORMAL)); }
2438         return ob->runtime.mesh_eval;
2439 }
2440
2441 #ifdef USE_DERIVEDMESH
2442 /* Deprecated DM, use: 'mesh_get_eval_deform' instead. */
2443 DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2444 {
2445         /* if there's no derived mesh or the last data mask used doesn't include
2446          * the data we need, rebuild the derived mesh
2447          */
2448         bool need_mapping;
2449
2450         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2451
2452         if (!ob->derivedDeform ||
2453             ((dataMask & ob->lastDataMask) != dataMask) ||
2454             (need_mapping != ob->lastNeedMapping))
2455         {
2456                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2457         }
2458
2459         return ob->derivedDeform;
2460 }
2461 #endif
2462 Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2463 {
2464         /* if there's no derived mesh or the last data mask used doesn't include
2465          * the data we need, rebuild the derived mesh
2466          */
2467         bool need_mapping;
2468
2469         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2470
2471         if (!ob->runtime.mesh_deform_eval ||
2472             ((dataMask & ob->lastDataMask) != dataMask) ||
2473             (need_mapping != ob->lastNeedMapping))
2474         {
2475                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2476         }
2477
2478         return ob->runtime.mesh_deform_eval;
2479 }
2480
2481
2482 DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2483 {
2484         DerivedMesh *final;
2485
2486         mesh_calc_modifiers_dm(
2487                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2488                 NULL, &final);
2489
2490         return final;
2491 }
2492
2493 #ifdef USE_DERIVEDMESH
2494 /* Deprecated, use `mesh_create_eval_final_index_render` instead. */
2495 DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask, int index)
2496 {
2497         DerivedMesh *final;
2498
2499         mesh_calc_modifiers_dm(
2500                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2501                 NULL, &final);
2502
2503         return final;
2504 }
2505 #endif
2506 struct Mesh *mesh_create_eval_final_index_render(
2507         struct Depsgraph *depsgraph, struct Scene *scene,
2508         struct Object *ob, CustomDataMask dataMask, int index)
2509 {
2510         Mesh *final;
2511
2512         mesh_calc_modifiers(
2513                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2514                 NULL, &final);
2515
2516         return final;
2517 }
2518
2519 #ifdef USE_DERIVEDMESH
2520 /* Deprecated, use `mesh_create_eval_final_view` instead. */
2521 DerivedMesh *mesh_create_derived_view(
2522         struct Depsgraph *depsgraph, Scene *scene,
2523         Object *ob, CustomDataMask dataMask)
2524 {
2525         DerivedMesh *final;
2526
2527         /* XXX hack
2528          * psys modifier updates particle state when called during dupli-list generation,
2529          * which can lead to wrong transforms. This disables particle system modifier execution.
2530          */
2531         ob->transflag |= OB_NO_PSYS_UPDATE;
2532
2533         mesh_calc_modifiers_dm(
2534                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2535                 NULL, &final);
2536
2537         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2538
2539         return final;
2540 }
2541 #endif
2542
2543 Mesh *mesh_create_eval_final_view(
2544         struct Depsgraph *depsgraph, Scene *scene,
2545         Object *ob, CustomDataMask dataMask)
2546 {
2547         Mesh *final;
2548
2549         /* XXX hack
2550          * psys modifier updates particle state when called during dupli-list generation,
2551          * which can lead to wrong transforms. This disables particle system modifier execution.
2552          */
2553         ob->transflag |= OB_NO_PSYS_UPDATE;
2554
2555         mesh_calc_modifiers(
2556                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2557                 NULL, &final);
2558
2559         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2560
2561         return final;
2562 }
2563
2564 DerivedMesh *mesh_create_derived_no_deform(
2565         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
2566         float (*vertCos)[3], CustomDataMask dataMask)
2567 {
2568         DerivedMesh *final;
2569
2570         mesh_calc_modifiers_dm(
2571                 depsgraph, scene, ob, vertCos, 0, false, dataMask, -1, false, false,
2572                 NULL, &final);
2573
2574         return final;
2575 }
2576
2577 /***/
2578
2579 DerivedMesh *editbmesh_get_derived_cage_and_final(
2580         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2581         CustomDataMask dataMask,
2582         /* return args */
2583         DerivedMesh **r_final)
2584 {
2585         /* if there's no derived mesh or the last data mask used doesn't include
2586          * the data we need, rebuild the derived mesh
2587          */
2588         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2589
2590         if (!em->derivedCage ||
2591             (em->lastDataMask & dataMask) != dataMask)
2592         {
2593                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2594         }
2595
2596         *r_final = em->derivedFinal;
2597         if (em->derivedFinal) { BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
2598         return em->derivedCage;
2599 }
2600
2601 DerivedMesh *editbmesh_get_derived_cage(
2602         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2603         CustomDataMask dataMask)
2604 {
2605         /* if there's no derived mesh or the last data mask used doesn't include
2606          * the data we need, rebuild the derived mesh
2607          */
2608         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2609
2610         if (!em->derivedCage ||
2611             (em->lastDataMask & dataMask) != dataMask)
2612         {
2613                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2614         }
2615
2616         return em->derivedCage;
2617 }
2618
2619 DerivedMesh *editbmesh_get_derived_base(Object *obedit, BMEditMesh *em, CustomDataMask data_mask)
2620 {
2621         return getEditDerivedBMesh(em, obedit, data_mask, NULL);
2622 }
2623
2624 /***/
2625
2626 /* get derived mesh from an object, using editbmesh if available. */
2627 DerivedMesh *object_get_derived_final(Object *ob, const bool for_render)
2628 {
2629         if (for_render) {
2630                 /* TODO(sergey): use proper derived render here in the future. */
2631                 return ob->derivedFinal;
2632         }
2633
2634         /* only return the editmesh if its from this object because
2635          * we don't a mesh from another object's modifier stack: T43122 */
2636         if (ob->type == OB_MESH) {
2637                 Mesh *me = ob->data;
2638                 BMEditMesh *em = me->edit_btmesh;
2639                 if (em && (em->ob == ob)) {
2640                         DerivedMesh *dm = em->derivedFinal;
2641                         return dm;
2642                 }
2643         }
2644
2645         return ob->derivedFinal;
2646 }
2647
2648
2649 /* UNUSED */
2650 #if 0
2651
2652 /* ********* For those who don't grasp derived stuff! (ton) :) *************** */
2653
2654 static void make_vertexcosnos__mapFunc(void *userData, int index, const float co[3],
2655                                        const float no_f[3], const short no_s[3])
2656 {
2657         DMCoNo *co_no = &((DMCoNo *)userData)[index];
2658
2659         /* check if we've been here before (normal should not be 0) */
2660         if (!is_zero_v3(co_no->no)) {
2661                 return;
2662         }
2663
2664         copy_v3_v3(co_no->co, co);
2665         if (no_f) {
2666                 copy_v3_v3(co_no->no, no_f);
2667         }
2668         else {
2669                 normal_short_to_float_v3(co_no->no, no_s);
2670         }
2671 }
2672
2673 /* always returns original amount me->totvert of vertices and normals, but fully deformed and subsurfered */
2674 /* this is needed for all code using vertexgroups (no subsurf support) */
2675 /* it stores the normals as floats, but they can still be scaled as shorts (32767 = unit) */
2676 /* in use now by vertex/weight paint and particle generating */
2677
2678 DMCoNo *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
2679 {
2680         Mesh *me = ob->data;
2681         DerivedMesh *dm;
2682         DMCoNo *vertexcosnos;
2683
2684         /* lets prevent crashing... */
2685         if (ob->type != OB_MESH || me->totvert == 0)
2686                 return NULL;
2687
2688         dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
2689
2690         if (dm->foreachMappedVert) {
2691                 vertexcosnos = MEM_calloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2692                 dm->foreachMappedVert(dm, make_vertexcosnos__mapFunc, vertexcosnos);
2693         }
2694         else {
2695                 DMCoNo *v_co_no = vertexcosnos = MEM_malloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2696                 int a;
2697                 for (a = 0; a < me->totvert; a++, v_co_no++) {
2698                         dm->getVertCo(dm, a, v_co_no->co);
2699                         dm->getVertNo(dm, a, v_co_no->no);
2700                 }
2701         }
2702
2703         dm->release(dm);
2704         return vertexcosnos;
2705 }
2706
2707 #endif
2708
2709 /* same as above but for vert coords */
2710 typedef struct {
2711         float (*vertexcos)[3];
2712         BLI_bitmap *vertex_visit;
2713 } MappedUserData;
2714
2715 static void make_vertexcos__mapFunc(
2716         void *userData, int index, const float co[3],
2717         const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
2718 {
2719         MappedUserData *mappedData = (MappedUserData *)userData;
2720
2721         if (BLI_BITMAP_TEST(mappedData->vertex_visit, index) == 0) {
2722                 /* we need coord from prototype vertex, not from copies,
2723                  * assume they stored in the beginning of vertex array stored in DM
2724                  * (mirror modifier for eg does this) */
2725                 copy_v3_v3(mappedData->vertexcos[index], co);
2726                 BLI_BITMAP_ENABLE(mappedData->vertex_visit, index);
2727         }
2728 }
2729
2730 void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int totcos)
2731 {
2732         if (dm->foreachMappedVert) {
2733                 MappedUserData userData;
2734                 memset(r_cos, 0, sizeof(*r_cos) * totcos);
2735                 userData.vertexcos = r_cos;
2736                 userData.vertex_visit = BLI_BITMAP_NEW(totcos, "vertexcos flags");
2737                 dm->foreachMappedVert(dm, make_vertexcos__mapFunc, &userData, DM_FOREACH_NOP);
2738                 MEM_freeN(userData.vertex_visit);
2739         }
2740         else {
2741                 int i;
2742                 for (i = 0; i < totcos; i++) {
2743                         dm->getVertCo(dm, i, r_cos[i]);
2744                 }
2745         }
2746 }
2747
2748 void DM_add_named_tangent_layer_for_uv(
2749         CustomData *uv_data, CustomData *tan_data, int numLoopData,
2750         const char *layer_name)
2751 {
2752         if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
2753             CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
2754         {
2755                 CustomData_add_layer_named(
2756                         tan_data, CD_TANGENT, CD_CALLOC, NULL,
2757                         numLoopData, layer_name);
2758         }
2759 }
2760
2761 void DM_calc_loop_tangents(
2762         DerivedMesh *dm, bool calc_active_tangent,
2763         const char (*tangent_names)[MAX_NAME], int tangent_names_len)
2764 {
2765         BKE_mesh_calc_loop_tangent_ex(
2766                 dm->getVertArray(dm),
2767                 dm->getPolyArray(dm), dm->getNumPolys(dm),
2768                 dm->getLoopArray(dm),
2769                 dm->getLoopTriArray(dm), dm->getNumLoopTri(dm),
2770                 &dm->loopData,
2771                 calc_active_tangent,
2772                 tangent_names, tangent_names_len,
2773                 CustomData_get_layer(&dm->polyData, CD_NORMAL),
2774                 dm->getLoopDataArray(dm, CD_NORMAL),
2775                 dm->getVertDataArray(dm, CD_ORCO),  /* may be NULL */
2776                 /* result */
2777                 &dm->loopData, dm->getNumLoops(dm),
2778                 &dm->tangent_mask);
2779 }
2780
2781 /* Set object's bounding box based on DerivedMesh min/max data */
2782 void DM_set_object_boundbox(Object *ob, DerivedMesh *dm)
2783 {
2784         float min[3], max[3];
2785
2786         INIT_MINMAX(min, max);
2787         dm->getMinMax(dm, min, max);
2788
2789         if (!ob->bb)
2790                 ob->bb = MEM_callocN(sizeof(BoundBox), "DM-BoundBox");
2791
2792         BKE_boundbox_init_from_minmax(ob->bb, min, max);
2793
2794         ob->bb->flag &= ~BOUNDBOX_DIRTY;
2795 }
2796
2797 void DM_init_origspace(DerivedMesh *dm)
2798 {
2799         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2800
2801         OrigSpaceLoop *lof_array = CustomData_get_layer(&dm->loopData, CD_ORIGSPACE_MLOOP);
2802         const int numpoly = dm->getNumPolys(dm);
2803         // const int numloop = dm->getNumLoops(dm);
2804         MVert *mv = dm->getVertArray(dm);
2805         MLoop *ml = dm->getLoopArray(dm);
2806         MPoly *mp = dm->getPolyArray(dm);
2807         int i, j, k;
2808
2809         float (*vcos_2d)[2] = NULL;
2810         BLI_array_staticdeclare(vcos_2d, 64);
2811
2812         for (i = 0; i < numpoly; i++, mp++) {
2813                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2814
2815                 if (mp->totloop == 3 || mp->totloop == 4) {
2816                         for (j = 0; j < mp->totloop; j++, lof++) {
2817                                 copy_v2_v2(lof->uv, default_osf[j]);
2818                         }
2819                 }
2820                 else {
2821                         MLoop *l = &ml[mp->loopstart];
2822                         float p_nor[3], co[3];
2823                         float mat[3][3];
2824
2825                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2826                         float translate[2], scale[2];
2827
2828                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2829                         axis_dominant_v3_to_m3(mat, p_nor);
2830
2831                         BLI_array_clear(vcos_2d);
2832                         BLI_array_reserve(vcos_2d, mp->totloop);
2833                         for (j = 0; j < mp->totloop; j++, l++) {
2834                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2835                                 copy_v2_v2(vcos_2d[j], co);
2836
2837                                 for (k = 0; k < 2; k++) {
2838                                         if (co[k] > max[k])
2839                                                 max[k] = co[k];
2840                                         else if (co[k] < min[k])
2841                                                 min[k] = co[k];
2842                                 }
2843                         }
2844
2845                         /* Brings min to (0, 0). */
2846                         negate_v2_v2(translate, min);
2847
2848                         /* Scale will bring max to (1, 1). */
2849                         sub_v2_v2v2(scale, max, min);
2850                         if (scale[0] == 0.0f)
2851                                 scale[0] = 1e-9f;
2852                         if (scale[1] == 0.0f)
2853                                 scale[1] = 1e-9f;
2854                         invert_v2(scale);
2855
2856                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2857                         for (j = 0; j < mp->totloop; j++, lof++) {
2858                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2859                                 mul_v2_v2(lof->uv, scale);
2860                         }
2861                 }
2862         }
2863
2864         dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
2865         BLI_array_free(vcos_2d);
2866 }
2867
2868 static void mesh_init_origspace(Mesh *mesh)
2869 {
2870         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2871
2872         OrigSpaceLoop *lof_array = CustomData_get_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP);
2873         const int numpoly = mesh->totpoly;
2874         // const int numloop = mesh->totloop;
2875         MVert *mv = mesh->mvert;
2876         MLoop *ml = mesh->mloop;
2877         MPoly *mp = mesh->mpoly;
2878         int i, j, k;
2879
2880         float (*vcos_2d)[2] = NULL;
2881         BLI_array_staticdeclare(vcos_2d, 64);
2882
2883         for (i = 0; i < numpoly; i++, mp++) {
2884                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2885
2886                 if (mp->totloop == 3 || mp->totloop == 4) {
2887                         for (j = 0; j < mp->totloop; j++, lof++) {
2888                                 copy_v2_v2(lof->uv, default_osf[j]);
2889                         }
2890                 }
2891                 else {
2892                         MLoop *l = &ml[mp->loopstart];
2893                         float p_nor[3], co[3];
2894                         float mat[3][3];
2895
2896                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2897                         float translate[2], scale[2];
2898
2899                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2900                         axis_dominant_v3_to_m3(mat, p_nor);
2901
2902                         BLI_array_clear(vcos_2d);
2903                         BLI_array_reserve(vcos_2d, mp->totloop);
2904                         for (j = 0; j < mp->totloop; j++, l++) {
2905                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2906                                 copy_v2_v2(vcos_2d[j], co);
2907
2908                                 for (k = 0; k < 2; k++) {
2909                                         if (co[k] > max[k])
2910                                                 max[k] = co[k];
2911                                         else if (co[k] < min[k])
2912                                                 min[k] = co[k];
2913                                 }
2914                         }
2915
2916                         /* Brings min to (0, 0). */
2917                         negate_v2_v2(translate, min);
2918
2919                         /* Scale will bring max to (1, 1). */
2920                         sub_v2_v2v2(scale, max, min);
2921                         if (scale[0] == 0.0f)
2922                                 scale[0] = 1e-9f;
2923                         if (scale[1] == 0.0f)
2924                                 scale[1] = 1e-9f;
2925                         invert_v2(scale);
2926
2927                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2928                         for (j = 0; j < mp->totloop; j++, lof++) {
2929                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2930                                 mul_v2_v2(lof->uv, scale);
2931                         }
2932                 }
2933         }
2934
2935         BKE_mesh_tessface_clear(mesh);
2936         BLI_array_free(vcos_2d);
2937 }
2938
2939
2940 /* derivedmesh info printing function,
2941  * to help track down differences DM output */
2942
2943 #ifndef NDEBUG
2944 #include "BLI_dynstr.h"
2945
2946 static void dm_debug_info_layers(
2947         DynStr *dynstr, DerivedMesh *dm, CustomData *cd,
2948         void *(*getElemDataArray)(DerivedMesh *, int))
2949 {
2950         int type;
2951
2952         for (type = 0; type < CD_NUMTYPES; type++) {
2953                 if (CustomData_has_layer(cd, type)) {
2954                         /* note: doesn't account for multiple layers */
2955                         const char *name = CustomData_layertype_name(type);
2956                         const int size = CustomData_sizeof(type);
2957                         const void *pt = getElemDataArray(dm, type);
2958                         const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
2959                         const char *structname;
2960                         int structnum;
2961                         CustomData_file_write_info(type, &structname, &structnum);
2962                         BLI_dynstr_appendf(dynstr,
2963                                            "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2964                                            name, structname, type, (const void *)pt, size, pt_size);
2965                 }
2966         }
2967 }
2968
2969 char *DM_debug_info(DerivedMesh *dm)
2970 {
2971         DynStr *dynstr = BLI_dynstr_new();
2972         char *ret;
2973         const char *tstr;
2974
2975         BLI_dynstr_appendf(dynstr, "{\n");
2976         BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)dm);
2977         switch (dm->type) {
2978                 case DM_TYPE_CDDM:     tstr = "DM_TYPE_CDDM";     break;
2979                 case DM_TYPE_EDITBMESH: tstr = "DM_TYPE_EDITMESH";  break;
2980                 case DM_TYPE_CCGDM:    tstr = "DM_TYPE_CCGDM";     break;
2981                 default:               tstr = "UNKNOWN";           break;
2982         }
2983         BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
2984         BLI_dynstr_appendf(dynstr, "    'numVertData': %d,\n", dm->numVertData);
2985         BLI_dynstr_appendf(dynstr, "    'numEdgeData': %d,\n", dm->numEdgeData);
2986         BLI_dynstr_appendf(dynstr, "    'numTessFaceData': %d,\n", dm->numTessFaceData);
2987         BLI_dynstr_appendf(dynstr, "    'numPolyData': %d,\n", dm->numPolyData);
2988         BLI_dynstr_appendf(dynstr, "    'deformedOnly': %d,\n", dm->deformedOnly);
2989
2990         BLI_dynstr_appendf(dynstr, "    'vertexLayers': (\n");
2991         dm_debug_info_layers(dynstr, dm, &dm->vertData, dm->getVertDataArray);
2992         BLI_dynstr_appendf(dynstr, "    ),\n");
2993
2994         BLI_dynstr_appendf(dynstr, "    'edgeLayers': (\n");
2995         dm_debug_info_layers(dynstr, dm, &dm->edgeData, dm->getEdgeDataArray);
2996         BLI_dynstr_appendf(dynstr, "    ),\n");
2997
2998         BLI_dynstr_appendf(dynstr, "    'loopLayers': (\n");
2999         dm_debug_info_layers(dynstr, dm, &dm->loopData, dm->getLoopDataArray);
3000         BLI_dynstr_appendf(dynstr, "    ),\n");
3001
3002         BLI_dynstr_appendf(dynstr, "    'polyLayers': (\n");
3003         dm_debug_info_layers(dynstr, dm, &dm->polyData, dm->getPolyDataArray);
3004         BLI_dynstr_appendf(dynstr, "    ),\n");
3005
3006         BLI_dynstr_appendf(dynstr, "    'tessFaceLayers': (\n");
3007         dm_debug_info_layers(dynstr, dm, &dm->faceData, dm->getTessFaceDataArray);
3008         BLI_dynstr_appendf(dynstr, "    ),\n");
3009
3010         BLI_dynstr_appendf(dynstr, "}\n");
3011
3012         ret = BLI_dynstr_get_cstring(dynstr);
3013         BLI_dynstr_free(dynstr);
3014         return ret;
3015 }
3016
3017 void DM_debug_print(DerivedMesh *dm)
3018 {
3019         char *str = DM_debug_info(dm);
3020         puts(str);
3021         fflush(stdout);
3022         MEM_freeN(str);
3023 }
3024
3025 void DM_debug_print_cdlayers(CustomData *data)
3026 {
3027         int i;
3028         const CustomDataLayer *layer;
3029
3030         printf("{\n");
3031
3032         for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
3033
3034                 const char *name = CustomData_layertype_name(layer->type);
3035                 const int size = CustomData_sizeof(layer->type);
3036                 const char *structname;
3037                 int structnum;
3038                 CustomData_file_write_info(layer->type, &structname, &structnum);
3039                 printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
3040                        name, structname, layer->type, (const void *)layer->data, size, (int)(MEM_allocN_len(layer->data) / size));
3041         }
3042
3043         printf("}\n");
3044 }
3045
3046 bool DM_is_valid(DerivedMesh *dm)
3047 {
3048         const bool do_verbose = true;
3049         const bool do_fixes = false;
3050
3051         bool is_valid = true;
3052         bool changed = true;
3053
3054         is_valid &= BKE_mesh_validate_all_customdata(
3055                 dm->getVertDataLayout(dm),
3056                 dm->getEdgeDataLayout(dm),
3057                 dm->getLoopDataLayout(dm),
3058                 dm->getPolyDataLayout(dm),
3059                 false,  /* setting mask here isn't useful, gives false positives */
3060                 do_verbose, do_fixes, &changed);
3061
3062         is_valid &= BKE_mesh_validate_arrays(
3063                 NULL,
3064                 dm->getVertArray(dm), dm->getNumVerts(dm),
3065                 dm->getEdgeArray(dm), dm->getNumEdges(dm),
3066                 dm->getTessFaceArray(dm), dm->getNumTessFaces(dm),
3067                 dm->getLoopArray(dm), dm->getNumLoops(dm),
3068                 dm->getPolyArray(dm), dm->getNumPolys(dm),
3069                 dm->getVertDataArray(dm, CD_MDEFORMVERT),
3070                 do_verbose, do_fixes, &changed);
3071
3072         BLI_assert(changed == false);
3073
3074         return is_valid;
3075 }
3076
3077 #endif /* NDEBUG */
3078
3079 /* -------------------------------------------------------------------- */
3080
3081 MVert *DM_get_vert_array(DerivedMesh *dm, bool *allocated)
3082 {
3083         CustomData *vert_data = dm->getVertDataLayout(dm);
3084         MVert *mvert = CustomData_get_layer(vert_data, CD_MVERT);
3085         *allocated = false;
3086
3087         if (mvert == NULL) {
3088                 mvert = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(MVert), "dmvh vert data array");
3089                 dm->copyVertArray(dm, mvert);
3090                 *allocated = true;
3091         }
3092
3093         return mvert;
3094 }
3095
3096 MEdge *DM_get_edge_array(DerivedMesh *dm, bool *allocated)
3097 {
3098         CustomData *edge_data = dm->getEdgeDataLayout(dm);
3099         MEdge *medge = CustomData_get_layer(edge_data, CD_MEDGE);
3100         *allocated = false;
3101
3102         if (medge == NULL) {
3103                 medge = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(MEdge), "dm medge data array");
3104                 dm->copyEdgeArray(dm, medge);
3105                 *allocated = true;
3106         }
3107
3108         return medge;
3109 }
3110
3111 MLoop *DM_get_loop_array(DerivedMesh *dm, bool *r_allocated)
3112 {
3113         CustomData *loop_data = dm->getLoopDataLayout(dm);
3114         MLoop *mloop = CustomData_get_layer(loop_data, CD_MLOOP);
3115         *r_allocated = false;
3116
3117         if (mloop == NULL) {
3118                 mloop = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(MLoop), "dm loop data array");
3119                 dm->copyLoopArray(dm, mloop);
3120                 *r_allocated = true;
3121         }
3122
3123         return mloop;
3124 }
3125
3126 MPoly *DM_get_poly_array(DerivedMesh *dm, bool *r_allocated)
3127 {
3128         CustomData *poly_data = dm->getPolyDataLayout(dm);
3129         MPoly *mpoly = CustomData_get_layer(poly_data, CD_MPOLY);
3130         *r_allocated = false;
3131
3132         if (mpoly == NULL) {
3133                 mpoly = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(MPoly), "dm poly data array");
3134                 dm->copyPolyArray(dm, mpoly);
3135                 *r_allocated = true;
3136         }
3137
3138         return mpoly;
3139 }
3140
3141 MFace *DM_get_tessface_array(DerivedMesh *dm, bool *r_allocated)
3142 {
3143         CustomData *tessface_data = dm->getTessFaceDataLayout(dm);
3144         MFace *mface = CustomData_get_layer(tessface_data, CD_MFACE);
3145         *r_allocated = false;
3146
3147         if (mface == NULL) {
3148                 int numTessFaces = dm->getNumTessFaces(dm);
3149
3150                 if (numTessFaces > 0) {
3151                         mface = MEM_malloc_arrayN(numTessFaces, sizeof(MFace), "bvh mface data array");
3152                         dm->copyTessFaceArray(dm, mface);
3153                         *r_allocated = true;
3154                 }
3155         }
3156
3157         return mface;
3158 }