Cleanup: remove unused EditDerivedBMesh
[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)
1263 {
1264         BMEditMesh *em = BKE_editmesh_from_object(ob);
1265         Mesh *me = ob->data;
1266         BKE_mesh_runtime_ensure_edit_data(me);
1267         BKE_editmesh_statvis_calc(em, me->runtime.edit_data, &scene->toolsettings->statvis);
1268 }
1269
1270 static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid)
1271 {
1272         KeyBlock *kb;
1273         int i, j, tot;
1274
1275         if (!me->key)
1276                 return;
1277
1278         tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
1279         for (i = 0; i < tot; i++) {
1280                 CustomDataLayer *layer = &dm->vertData.layers[CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i)];
1281                 float (*cos)[3], (*kbcos)[3];
1282
1283                 for (kb = me->key->block.first; kb; kb = kb->next) {
1284                         if (kb->uid == layer->uid)
1285                                 break;
1286                 }
1287
1288                 if (!kb) {
1289                         kb = BKE_keyblock_add(me->key, layer->name);
1290                         kb->uid = layer->uid;
1291                 }
1292
1293                 if (kb->data)
1294                         MEM_freeN(kb->data);
1295
1296                 cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
1297                 kb->totelem = dm->numVertData;
1298
1299                 kb->data = kbcos = MEM_malloc_arrayN(kb->totelem, 3 * sizeof(float), "kbcos DerivedMesh.c");
1300                 if (kb->uid == actshape_uid) {
1301                         MVert *mvert = dm->getVertArray(dm);
1302
1303                         for (j = 0; j < dm->numVertData; j++, kbcos++, mvert++) {
1304                                 copy_v3_v3(*kbcos, mvert->co);
1305                         }
1306                 }
1307                 else {
1308                         for (j = 0; j < kb->totelem; j++, cos++, kbcos++) {
1309                                 copy_v3_v3(*kbcos, *cos);
1310                         }
1311                 }
1312         }
1313
1314         for (kb = me->key->block.first; kb; kb = kb->next) {
1315                 if (kb->totelem != dm->numVertData) {
1316                         if (kb->data)
1317                                 MEM_freeN(kb->data);
1318
1319                         kb->totelem = dm->numVertData;
1320                         kb->data = MEM_calloc_arrayN(kb->totelem, 3 * sizeof(float), "kb->data derivedmesh.c");
1321                         fprintf(stderr, "%s: lost a shapekey layer: '%s'! (bmesh internal error)\n", __func__, kb->name);
1322                 }
1323         }
1324 }
1325
1326 static void UNUSED_FUNCTION(add_shapekey_layers)(DerivedMesh *dm, Mesh *me, Object *UNUSED(ob))
1327 {
1328         KeyBlock *kb;
1329         Key *key = me->key;
1330         int i;
1331
1332         if (!me->key)
1333                 return;
1334
1335         /* ensure we can use mesh vertex count for derived mesh custom data */
1336         if (me->totvert != dm->getNumVerts(dm)) {
1337                 fprintf(stderr,
1338                         "%s: vertex size mismatch (mesh/dm) '%s' (%d != %d)\n",
1339                         __func__, me->id.name + 2, me->totvert, dm->getNumVerts(dm));
1340                 return;
1341         }
1342
1343         for (i = 0, kb = key->block.first; kb; kb = kb->next, i++) {
1344                 int ci;
1345                 float *array;
1346
1347                 if (me->totvert != kb->totelem) {
1348                         fprintf(stderr,
1349                                 "%s: vertex size mismatch (Mesh '%s':%d != KeyBlock '%s':%d)\n",
1350                                 __func__, me->id.name + 2, me->totvert, kb->name, kb->totelem);
1351                         array = MEM_calloc_arrayN((size_t)me->totvert, 3 * sizeof(float), __func__);
1352                 }
1353                 else {
1354                         array = MEM_malloc_arrayN((size_t)me->totvert, 3 * sizeof(float), __func__);
1355                         memcpy(array, kb->data, (size_t)me->totvert * 3 * sizeof(float));
1356                 }
1357
1358                 CustomData_add_layer_named(&dm->vertData, CD_SHAPEKEY, CD_ASSIGN, array, dm->numVertData, kb->name);
1359                 ci = CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i);
1360
1361                 dm->vertData.layers[ci].uid = kb->uid;
1362         }
1363 }
1364
1365 /**
1366  * Called after calculating all modifiers.
1367  *
1368  * \note tessfaces should already be calculated.
1369  */
1370 static void mesh_ensure_display_normals(Mesh *mesh)
1371 {
1372         /* Note: mesh *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
1373          *       We do not use it here, though. And it should be tagged as temp!
1374          */
1375         /* BLI_assert((CustomData_has_layer(&mesh->pdata, CD_NORMAL) == false)); */
1376
1377         if (mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL || !CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
1378                 float (*face_nors)[3] = NULL;
1379                 face_nors = MEM_malloc_arrayN(mesh->totpoly, sizeof(*face_nors), "face_nors");
1380
1381                 /* if normals are dirty we want to calculate vertex normals too */
1382                 bool only_face_normals = !(mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL);
1383
1384                 /* calculate face normals */
1385                 BKE_mesh_calc_normals_poly(
1386                         mesh->mvert, NULL, mesh->totvert, mesh->mloop, mesh->mpoly,
1387                         mesh->totloop, mesh->totpoly, face_nors,
1388                         only_face_normals);
1389
1390                 CustomData_add_layer(&mesh->pdata, CD_NORMAL, CD_ASSIGN, face_nors, mesh->totpoly);
1391
1392                 mesh->runtime.cd_dirty_vert &= ~CD_MASK_NORMAL;
1393         }
1394 }
1395
1396 static void mesh_calc_modifiers(
1397         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
1398         int useDeform,
1399         const bool need_mapping, CustomDataMask dataMask,
1400         const int index, const bool useCache, const bool build_shapekey_layers,
1401         /* return args */
1402         Mesh **r_deform_mesh, Mesh **r_final_mesh)
1403 {
1404         Mesh *me = ob->data;
1405         ModifierData *firstmd, *md, *previewmd = NULL;
1406         CDMaskLink *datamasks, *curr;
1407         /* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
1408         CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX;
1409         float (*deformedVerts)[3] = NULL;
1410         int numVerts = me->totvert;
1411         const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
1412         const int required_mode = useRenderParams ? eModifierMode_Render : eModifierMode_Realtime;
1413         bool isPrevDeform = false;
1414         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
1415         const bool has_multires = (mmd && mmd->sculptlvl != 0);
1416         bool multires_applied = false;
1417         const bool sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt && !useRenderParams;
1418         const bool sculpt_dyntopo = (sculpt_mode && ob->sculpt->bm)  && !useRenderParams;
1419
1420         /* Generic preview only in object mode! */
1421         const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
1422         const bool do_loop_normals = (me->flag & ME_AUTOSMOOTH) != 0;
1423
1424         VirtualModifierData virtualModifierData;
1425
1426         ModifierApplyFlag app_flags = useRenderParams ? MOD_APPLY_RENDER : 0;
1427         ModifierApplyFlag deform_app_flags = app_flags;
1428
1429         BLI_assert((me->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
1430
1431         if (useCache)
1432                 app_flags |= MOD_APPLY_USECACHE;
1433         if (useDeform)
1434                 deform_app_flags |= MOD_APPLY_USECACHE;
1435
1436         /* TODO(sybren): do we really need three context objects? Or do we modify
1437          * them on the fly to change the flags where needed? */
1438         const ModifierEvalContext mectx_deform = {depsgraph, ob, deform_app_flags};
1439         const ModifierEvalContext mectx_apply = {depsgraph, ob, app_flags};
1440         const ModifierEvalContext mectx_orco = {depsgraph, ob, (app_flags & ~MOD_APPLY_USECACHE) | MOD_APPLY_ORCO};
1441
1442         md = firstmd = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1443
1444         modifiers_clearErrors(ob);
1445
1446         if (do_mod_mcol) {
1447                 /* Find the last active modifier generating a preview, or NULL if none. */
1448                 /* XXX Currently, DPaint modifier just ignores this.
1449                  *     Needs a stupid hack...
1450                  *     The whole "modifier preview" thing has to be (re?)designed, anyway! */
1451                 previewmd = modifiers_getLastPreview(scene, md, required_mode);
1452         }
1453
1454         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
1455         curr = datamasks;
1456
1457         if (r_deform_mesh) {
1458                 *r_deform_mesh = NULL;
1459         }
1460         *r_final_mesh = NULL;
1461
1462         if (useDeform) {
1463                 if (inputVertexCos)
1464                         deformedVerts = inputVertexCos;
1465
1466                 /* Apply all leading deforming modifiers */
1467                 for (; md; md = md->next, curr = curr->next) {
1468                         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1469
1470                         if (!modifier_isEnabled(scene, md, required_mode)) {
1471                                 continue;
1472                         }
1473
1474                         if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1475                                 continue;
1476                         }
1477
1478                         if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
1479                                 if (!deformedVerts)
1480                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1481
1482                                 modwrap_deformVerts(md, &mectx_deform, NULL, deformedVerts, numVerts);
1483                         }
1484                         else {
1485                                 break;
1486                         }
1487
1488                         /* grab modifiers until index i */
1489                         if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
1490                                 break;
1491                 }
1492
1493                 /* Result of all leading deforming modifiers is cached for
1494                  * places that wish to use the original mesh but with deformed
1495                  * coordinates (vpaint, etc.)
1496                  */
1497                 if (r_deform_mesh) {
1498                         *r_deform_mesh = BKE_mesh_copy_for_eval(me, true);
1499
1500                         /* XXX: Is build_shapekey_layers ever even true? This should have crashed long ago... */
1501                         BLI_assert(!build_shapekey_layers);
1502                         UNUSED_VARS_NDEBUG(build_shapekey_layers);
1503                         //if (build_shapekey_layers)
1504                         //      add_shapekey_layers(*r_deform_mesh, me, ob);
1505
1506                         if (deformedVerts) {
1507                                 BKE_mesh_apply_vert_coords(*r_deform_mesh, deformedVerts);
1508                         }
1509                 }
1510         }
1511         else {
1512                 /* default behavior for meshes */
1513                 if (inputVertexCos)
1514                         deformedVerts = inputVertexCos;
1515                 else
1516                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1517         }
1518
1519
1520         /* Now apply all remaining modifiers. If useDeform is off then skip
1521          * OnlyDeform ones.
1522          */
1523         Mesh *mesh = NULL;
1524         Mesh *orco_mesh = NULL;
1525         Mesh *cloth_orco_mesh = NULL;
1526
1527         for (; md; md = md->next, curr = curr->next) {
1528                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1529
1530                 if (!modifier_isEnabled(scene, md, required_mode)) {
1531                         continue;
1532                 }
1533
1534                 if (mti->type == eModifierTypeType_OnlyDeform && !useDeform) {
1535                         continue;
1536                 }
1537
1538                 if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && mesh) {
1539                         modifier_setError(md, "Modifier requires original data, bad stack position");
1540                         continue;
1541                 }
1542
1543                 if (sculpt_mode &&
1544                     (!has_multires || multires_applied || sculpt_dyntopo))
1545                 {
1546                         bool unsupported = false;
1547
1548                         if (md->type == eModifierType_Multires && ((MultiresModifierData *)md)->sculptlvl == 0) {
1549                                 /* If multires is on level 0 skip it silently without warning message. */
1550                                 if (!sculpt_dyntopo) {
1551                                         continue;
1552                                 }
1553                         }
1554
1555                         if (sculpt_dyntopo && !useRenderParams)
1556                                 unsupported = true;
1557
1558                         if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM)
1559                                 unsupported |= (mti->type != eModifierTypeType_OnlyDeform);
1560
1561                         unsupported |= multires_applied;
1562
1563                         if (unsupported) {
1564                                 if (sculpt_dyntopo)
1565                                         modifier_setError(md, "Not supported in dyntopo");
1566                                 else
1567                                         modifier_setError(md, "Not supported in sculpt mode");
1568                                 continue;
1569                         }
1570                         else {
1571                                 modifier_setError(md, "Hide, Mask and optimized display disabled");
1572                         }
1573                 }
1574
1575                 if (need_mapping && !modifier_supportsMapping(md)) {
1576                         continue;
1577                 }
1578
1579                 if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
1580                         continue;
1581                 }
1582
1583                 /* add an orco layer if needed by this modifier */
1584                 if (mti->requiredDataMask)
1585                         mask = mti->requiredDataMask(ob, md);
1586                 else
1587                         mask = 0;
1588
1589                 if (mesh && (mask & CD_MASK_ORCO)) {
1590                         add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_ORCO);
1591                 }
1592
1593                 /* How to apply modifier depends on (a) what we already have as
1594                  * a result of previous modifiers (could be a Mesh or just
1595                  * deformed vertices) and (b) what type the modifier is.
1596                  */
1597
1598                 if (mti->type == eModifierTypeType_OnlyDeform) {
1599                         /* No existing verts to deform, need to build them. */
1600                         if (!deformedVerts) {
1601                                 if (mesh) {
1602                                         /* Deforming a mesh, read the vertex locations
1603                                          * out of the mesh and deform them. Once done with this
1604                                          * run of deformers verts will be written back.
1605                                          */
1606                                         deformedVerts = BKE_mesh_vertexCos_get(mesh, &numVerts);
1607                                 }
1608                                 else {
1609                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1610                                 }
1611                         }
1612
1613                         /* if this is not the last modifier in the stack then recalculate the normals
1614                          * to avoid giving bogus normals to the next modifier see: [#23673] */
1615                         if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1616                                 /* XXX, this covers bug #23673, but we may need normal calc for other types */
1617                                 if (mesh) {
1618                                         BKE_mesh_apply_vert_coords(mesh, deformedVerts);
1619                                 }
1620                         }
1621
1622                         modwrap_deformVerts(md, &mectx_deform, mesh, deformedVerts, numVerts);
1623                 }
1624                 else {
1625                         /* determine which data layers are needed by following modifiers */
1626                         if (curr->next)
1627                                 nextmask = curr->next->mask;
1628                         else
1629                                 nextmask = dataMask;
1630
1631                         /* apply vertex coordinates or build a Mesh as necessary */
1632                         if (mesh) {
1633                                 if (deformedVerts) {
1634                                         BKE_mesh_apply_vert_coords(mesh, deformedVerts);
1635                                 }
1636                         }
1637                         else {
1638                                 mesh = BKE_mesh_copy_for_eval(me, true);
1639                                 ASSERT_IS_VALID_MESH(mesh);
1640
1641                                 // XXX: port to Mesh if build_shapekey_layers can ever be true
1642                                 //if (build_shapekey_layers)
1643                                 //      add_shapekey_layers(mesh, me, ob);
1644
1645                                 if (deformedVerts) {
1646                                         BKE_mesh_apply_vert_coords(mesh, deformedVerts);
1647                                 }
1648
1649                                 /* Constructive modifiers need to have an origindex
1650                                  * otherwise they wont have anywhere to copy the data from.
1651                                  *
1652                                  * Also create ORIGINDEX data if any of the following modifiers
1653                                  * requests it, this way Mirror, Solidify etc will keep ORIGINDEX
1654                                  * data by using generic DM_copy_vert_data() functions.
1655                                  */
1656                                 if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
1657                                         /* calc */
1658                                         CustomData_add_layer(&mesh->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totvert);
1659                                         CustomData_add_layer(&mesh->edata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totedge);
1660                                         CustomData_add_layer(&mesh->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totpoly);
1661
1662                                         /* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
1663                                         range_vn_i(CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX), mesh->totvert, 0);
1664                                         range_vn_i(CustomData_get_layer(&mesh->edata, CD_ORIGINDEX), mesh->totedge, 0);
1665                                         range_vn_i(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX), mesh->totpoly, 0);
1666                                 }
1667                         }
1668
1669
1670                         /* set the Mesh to only copy needed data */
1671                         mask = curr->mask;
1672                         /* needMapping check here fixes bug [#28112], otherwise it's
1673                          * possible that it won't be copied */
1674                         mask |= append_mask;
1675                         mesh_set_only_copy(mesh, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
1676
1677                         /* add cloth rest shape key if needed */
1678                         if (mask & CD_MASK_CLOTH_ORCO)
1679                                 add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_CLOTH_ORCO);
1680
1681                         /* add an origspace layer if needed */
1682                         if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
1683                                 if (!CustomData_has_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP)) {
1684                                         CustomData_add_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh->totloop);
1685                                         mesh_init_origspace(mesh);
1686                                 }
1687                         }
1688
1689                         Mesh *new_mesh = modwrap_applyModifier(md, &mectx_apply, mesh);
1690                         ASSERT_IS_VALID_MESH(new_mesh);
1691
1692                         if (new_mesh) {
1693                                 /* if the modifier returned a new mesh, release the old one */
1694                                 if (mesh && mesh != new_mesh) {
1695                                         BLI_assert(mesh != me);
1696                                         BKE_id_free(NULL, mesh);
1697                                 }
1698
1699                                 mesh = new_mesh;
1700
1701                                 if (deformedVerts) {
1702                                         if (deformedVerts != inputVertexCos)
1703                                                 MEM_freeN(deformedVerts);
1704
1705                                         deformedVerts = NULL;
1706                                 }
1707                         }
1708
1709                         /* create an orco mesh in parallel */
1710                         if (nextmask & CD_MASK_ORCO) {
1711                                 if (!orco_mesh) {
1712                                         orco_mesh = create_orco_mesh(ob, me, NULL, CD_ORCO);
1713                                 }
1714
1715                                 nextmask &= ~CD_MASK_ORCO;
1716                                 mesh_set_only_copy(orco_mesh, nextmask | CD_MASK_ORIGINDEX |
1717                                                  (mti->requiredDataMask ?
1718                                                   mti->requiredDataMask(ob, md) : 0));
1719
1720                                 new_mesh = modwrap_applyModifier(md, &mectx_orco, orco_mesh);
1721                                 ASSERT_IS_VALID_MESH(new_mesh);
1722
1723                                 if (new_mesh) {
1724                                         /* if the modifier returned a new mesh, release the old one */
1725                                         if (orco_mesh && orco_mesh != new_mesh) {
1726                                                 BLI_assert(orco_mesh != me);
1727                                                 BKE_id_free(NULL, orco_mesh);
1728                                         }
1729
1730                                         orco_mesh = new_mesh;
1731                                 }
1732                         }
1733
1734                         /* create cloth orco mesh in parallel */
1735                         if (nextmask & CD_MASK_CLOTH_ORCO) {
1736                                 if (!cloth_orco_mesh) {
1737                                         cloth_orco_mesh = create_orco_mesh(ob, me, NULL, CD_CLOTH_ORCO);
1738                                 }
1739
1740                                 nextmask &= ~CD_MASK_CLOTH_ORCO;
1741                                 mesh_set_only_copy(cloth_orco_mesh, nextmask | CD_MASK_ORIGINDEX);
1742
1743                                 new_mesh = modwrap_applyModifier(md, &mectx_orco, cloth_orco_mesh);
1744                                 ASSERT_IS_VALID_DM(new_mesh);
1745
1746                                 if (new_mesh) {
1747                                         /* if the modifier returned a new mesh, release the old one */
1748                                         if (cloth_orco_mesh && cloth_orco_mesh != new_mesh) {
1749                                                 BLI_assert(orco_mesh != me);
1750                                                 BKE_id_free(NULL, cloth_orco_mesh);
1751                                         }
1752
1753                                         cloth_orco_mesh = new_mesh;
1754                                 }
1755                         }
1756
1757                         /* in case of dynamic paint, make sure preview mask remains for following modifiers */
1758                         /* XXX Temp and hackish solution! */
1759                         if (md->type == eModifierType_DynamicPaint)
1760                                 append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
1761
1762                         mesh->runtime.deformed_only = false;
1763                 }
1764
1765                 isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
1766
1767                 /* grab modifiers until index i */
1768                 if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
1769                         break;
1770
1771                 if (sculpt_mode && md->type == eModifierType_Multires) {
1772                         multires_applied = true;
1773                 }
1774         }
1775
1776         for (md = firstmd; md; md = md->next)
1777                 modifier_freeTemporaryData(md);
1778
1779         /* Yay, we are done. If we have a Mesh and deformed vertices
1780          * need to apply these back onto the Mesh. If we have no
1781          * Mesh then we need to build one.
1782          */
1783         Mesh *final_mesh;
1784
1785         if (mesh) {
1786                 final_mesh = mesh;
1787
1788                 if (deformedVerts) {
1789                         BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
1790                 }
1791         }
1792         else {
1793                 final_mesh = BKE_mesh_copy_for_eval(me, true);
1794
1795                 //if (build_shapekey_layers) {
1796                 //      add_shapekey_layers(final_mesh, me, ob);
1797                 //}
1798
1799                 if (deformedVerts) {
1800                         BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
1801                 }
1802         }
1803
1804         /* add an orco layer if needed */
1805         if (dataMask & CD_MASK_ORCO) {
1806                 add_orco_mesh(ob, NULL, final_mesh, orco_mesh, CD_ORCO);
1807
1808                 if (r_deform_mesh && *r_deform_mesh)
1809                         add_orco_mesh(ob, NULL, *r_deform_mesh, NULL, CD_ORCO);
1810         }
1811
1812         if (do_loop_normals) {
1813                 /* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
1814                 BKE_mesh_calc_normals_split(final_mesh);
1815                 BKE_mesh_tessface_clear(final_mesh);
1816         }
1817
1818         if (sculpt_dyntopo == false) {
1819                 /* watch this! after 2.75a we move to from tessface to looptri (by default) */
1820                 if (dataMask & CD_MASK_MFACE) {
1821                         BKE_mesh_tessface_ensure(final_mesh);
1822                 }
1823
1824                 /* without this, drawing ngon tri's faces will show ugly tessellated face
1825                  * normals and will also have to calculate normals on the fly, try avoid
1826                  * this where possible since calculating polygon normals isn't fast,
1827                  * note that this isn't a problem for subsurf (only quads) or editmode
1828                  * which deals with drawing differently.
1829                  *
1830                  * Only calc vertex normals if they are flagged as dirty.
1831                  * If using loop normals, poly nors have already been computed.
1832                  */
1833                 if (!do_loop_normals) {
1834                         mesh_ensure_display_normals(final_mesh);
1835                 }
1836         }
1837
1838         /* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
1839          * as they are used by display code when available (i.e. even if autosmooth is disabled). */
1840         if (!do_loop_normals && CustomData_has_layer(&final_mesh->ldata, CD_NORMAL)) {
1841                 CustomData_free_layers(&final_mesh->ldata, CD_NORMAL, final_mesh->totloop);
1842         }
1843
1844         *r_final_mesh = final_mesh;
1845
1846         if (orco_mesh) {
1847                 BKE_id_free(NULL, orco_mesh);
1848         }
1849         if (cloth_orco_mesh) {
1850                 BKE_id_free(NULL, cloth_orco_mesh);
1851         }
1852
1853         if (deformedVerts && deformedVerts != inputVertexCos)
1854                 MEM_freeN(deformedVerts);
1855
1856         BLI_linklist_free((LinkNode *)datamasks, NULL);
1857 }
1858
1859 static void mesh_calc_modifiers_dm(
1860         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
1861         int useDeform,
1862         const bool need_mapping, CustomDataMask dataMask,
1863         const int index, const bool useCache, const bool build_shapekey_layers,
1864         /* return args */
1865         DerivedMesh **r_deformdm, DerivedMesh **r_finaldm)
1866 {
1867         Mesh *deform_mesh = NULL, *final_mesh = NULL;
1868
1869         mesh_calc_modifiers(
1870                 depsgraph, scene, ob, inputVertexCos, useDeform,
1871                 need_mapping, dataMask, index, useCache, build_shapekey_layers,
1872                 (r_deformdm ? &deform_mesh : NULL), &final_mesh);
1873
1874         if (deform_mesh) {
1875                 *r_deformdm = CDDM_from_mesh_ex(deform_mesh, CD_DUPLICATE, CD_MASK_MESH);
1876                 BKE_id_free(NULL, deform_mesh);
1877         }
1878
1879         *r_finaldm = CDDM_from_mesh_ex(final_mesh, CD_DUPLICATE, CD_MASK_MESH);
1880         BKE_id_free(NULL, final_mesh);
1881 }
1882
1883 float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
1884 {
1885         BMIter iter;
1886         BMVert *eve;
1887         float (*cos)[3];
1888         int i;
1889
1890         *r_numVerts = em->bm->totvert;
1891
1892         cos = MEM_malloc_arrayN(em->bm->totvert, 3 * sizeof(float), "vertexcos");
1893
1894         BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
1895                 copy_v3_v3(cos[i], eve->co);
1896         }
1897
1898         return cos;
1899 }
1900
1901 bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev_mesh)
1902 {
1903         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1904         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1905
1906         if (!modifier_isEnabled(scene, md, required_mode)) {
1907                 return false;
1908         }
1909
1910         if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && has_prev_mesh) {
1911                 modifier_setError(md, "Modifier requires original data, bad stack position");
1912                 return false;
1913         }
1914
1915         return true;
1916 }
1917
1918 static void editbmesh_calc_modifiers(
1919         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
1920         BMEditMesh *em, CustomDataMask dataMask,
1921         /* return args */
1922         Mesh **r_cage, Mesh **r_final)
1923 {
1924         ModifierData *md;
1925         float (*deformedVerts)[3] = NULL;
1926         CustomDataMask mask = 0, append_mask = 0;
1927         Mesh *me = NULL;
1928         Mesh *me_orco = NULL;
1929         int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
1930         CDMaskLink *datamasks, *curr;
1931         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1932
1933 #if 0
1934         const bool do_init_statvis = false;
1935 #endif
1936         VirtualModifierData virtualModifierData;
1937
1938         /* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
1939         const ModifierEvalContext mectx = {depsgraph, ob, 0};
1940         const ModifierEvalContext mectx_orco = {depsgraph, ob, MOD_APPLY_ORCO};
1941         const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE};
1942
1943         const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
1944
1945         modifiers_clearErrors(ob);
1946
1947         if (r_cage && cageIndex == -1) {
1948                 *r_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, dataMask, NULL);
1949         }
1950
1951         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1952
1953         /* copied from mesh_calc_modifiers */
1954         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
1955
1956         curr = datamasks;
1957         for (i = 0; md; i++, md = md->next, curr = curr->next) {
1958                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1959
1960                 if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
1961                         continue;
1962                 }
1963
1964                 /* add an orco layer if needed by this modifier */
1965                 if (me && mti->requiredDataMask) {
1966                         mask = mti->requiredDataMask(ob, md);
1967                         if (mask & CD_MASK_ORCO) {
1968                                 add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
1969                         }
1970                 }
1971
1972                 /* How to apply modifier depends on (a) what we already have as
1973                  * a result of previous modifiers (could be a DerivedMesh or just
1974                  * deformed vertices) and (b) what type the modifier is.
1975                  */
1976
1977                 if (mti->type == eModifierTypeType_OnlyDeform) {
1978                         /* No existing verts to deform, need to build them. */
1979                         if (!deformedVerts) {
1980                                 if (me) {
1981                                         /* Deforming a derived mesh, read the vertex locations
1982                                          * out of the mesh and deform them. Once done with this
1983                                          * run of deformers verts will be written back.
1984                                          */
1985                                         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
1986                                 }
1987                                 else {
1988                                         deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
1989                                 }
1990                         }
1991
1992                         if (mti->deformVertsEM)
1993                                 modwrap_deformVertsEM(md, &mectx, em, me, deformedVerts, numVerts);
1994                         else
1995                                 modwrap_deformVerts(md, &mectx, me, deformedVerts, numVerts);
1996                 }
1997                 else {
1998                         Mesh *me_next;
1999
2000                         /* apply vertex coordinates or build a DerivedMesh as necessary */
2001                         if (me) {
2002                                 if (deformedVerts) {
2003                                         Mesh *me_temp = BKE_mesh_copy_for_eval(me, false);
2004
2005                                         if (!(r_cage && me == *r_cage)) {
2006                                                 BKE_id_free(NULL, me);
2007                                         }
2008                                         me = me_temp;
2009                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
2010                                 }
2011                                 else if (r_cage && me == *r_cage) {
2012                                         /* 'me' may be changed by this modifier, so we need to copy it. */
2013                                         me = BKE_mesh_copy_for_eval(me, false);
2014                                 }
2015
2016                         }
2017                         else {
2018                                 me = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
2019                                 ASSERT_IS_VALID_MESH(me);
2020
2021                                 if (deformedVerts) {
2022                                         BKE_mesh_apply_vert_coords(me, deformedVerts);
2023                                 }
2024                         }
2025
2026                         /* create an orco derivedmesh in parallel */
2027                         mask = curr->mask;
2028                         if (mask & CD_MASK_ORCO) {
2029                                 if (!me_orco) {
2030                                         me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
2031                                 }
2032
2033                                 mask &= ~CD_MASK_ORCO;
2034                                 mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
2035
2036                                 if (mti->applyModifierEM) {
2037                                         me_next = modwrap_applyModifierEM(md, &mectx_orco, em, me_orco);
2038                                 }
2039                                 else {
2040                                         me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
2041                                 }
2042                                 ASSERT_IS_VALID_MESH(me_next);
2043
2044                                 if (me_next) {
2045                                         /* if the modifier returned a new dm, release the old one */
2046                                         if (me_orco && me_orco != me_next) {
2047                                                 BKE_id_free(NULL, me_orco);
2048                                         }
2049                                         me_orco = me_next;
2050                                 }
2051                         }
2052
2053                         /* set the DerivedMesh to only copy needed data */
2054                         mask |= append_mask;
2055                         mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
2056
2057                         mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
2058
2059                         if (mask & CD_MASK_ORIGSPACE_MLOOP) {
2060                                 if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
2061                                         CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
2062                                         mesh_init_origspace(me);
2063                                 }
2064                         }
2065
2066                         if (mti->applyModifierEM) {
2067                                 me_next = modwrap_applyModifierEM(md, &mectx_cache, em, me);
2068                         }
2069                         else {
2070                                 me_next = modwrap_applyModifier(md, &mectx_cache, me);
2071                         }
2072                         ASSERT_IS_VALID_MESH(me_next);
2073
2074                         if (me_next) {
2075                                 if (me && me != me_next) {
2076                                         BKE_id_free(NULL, me);
2077                                 }
2078                                 me = me_next;
2079
2080                                 if (deformedVerts) {
2081                                         MEM_freeN(deformedVerts);
2082                                         deformedVerts = NULL;
2083                                 }
2084                         }
2085                         me->runtime.deformed_only = false;
2086                 }
2087
2088                 if (r_cage && i == cageIndex) {
2089                         if (me && deformedVerts) {
2090                                 *r_cage = BKE_mesh_copy_for_eval(me, false);
2091                                 BKE_mesh_apply_vert_coords(*r_cage, deformedVerts);
2092                         }
2093                         else if (me) {
2094                                 *r_cage = me;
2095                         }
2096                         else {
2097                                 struct Mesh *me_orig = ob->data;
2098                                 if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2099                                         BKE_mesh_runtime_ensure_edit_data(me_orig);
2100                                         me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
2101                                 }
2102                                 *r_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(
2103                                         em, mask,
2104                                         deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
2105                         }
2106                 }
2107         }
2108
2109         BLI_linklist_free((LinkNode *)datamasks, NULL);
2110
2111         /* Yay, we are done. If we have a DerivedMesh and deformed vertices need
2112          * to apply these back onto the DerivedMesh. If we have no DerivedMesh
2113          * then we need to build one.
2114          */
2115         if (me && deformedVerts) {
2116                 *r_final = BKE_mesh_copy_for_eval(me, false);
2117
2118                 if (!(r_cage && me == *r_cage)) {
2119                         BKE_id_free(NULL, me);
2120                 }
2121                 BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
2122         }
2123         else if (me) {
2124                 *r_final = me;
2125         }
2126         else if (!deformedVerts && r_cage && *r_cage) {
2127                 /* cage should already have up to date normals */
2128                 *r_final = *r_cage;
2129
2130 #if 0
2131                 /* In this case, we should never have weight-modifying modifiers in stack... */
2132                 if (do_init_statvis) {
2133                         DM_update_statvis_color(scene, ob);
2134                 }
2135 #endif
2136         }
2137         else {
2138                 /* this is just a copy of the editmesh, no need to calc normals */
2139                 struct Mesh *mesh = ob->data;
2140                 if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2141                         BKE_mesh_runtime_ensure_edit_data(mesh);
2142                         if (mesh->runtime.edit_data->vertexCos != NULL)
2143                                 MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
2144                         mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
2145                 }
2146                 *r_final = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, dataMask, deformedVerts);
2147                 deformedVerts = NULL;
2148
2149 #if 0
2150                 /* In this case, we should never have weight-modifying modifiers in stack... */
2151                 if (do_init_statvis) {
2152                         DM_update_statvis_color(scene, ob);
2153                 }
2154 #endif
2155         }
2156
2157         if (do_loop_normals) {
2158                 /* Compute loop normals */
2159                 BKE_mesh_calc_normals_split(*r_final);
2160                 BKE_mesh_tessface_clear(*r_final);
2161                 if (r_cage && *r_cage && (*r_cage != *r_final)) {
2162                         BKE_mesh_calc_normals_split(*r_cage);
2163                         BKE_mesh_tessface_clear(*r_cage);
2164                 }
2165         }
2166
2167         /* BMESH_ONLY, ensure tessface's used for drawing,
2168          * but don't recalculate if the last modifier in the stack gives us tessfaces
2169          * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
2170          * but quiets annoying error messages since tessfaces wont be created. */
2171         if (dataMask & CD_MASK_MFACE) {
2172                 if ((*r_final)->edit_btmesh == NULL) {
2173                         BKE_mesh_tessface_ensure(*r_final);
2174                 }
2175                 if (r_cage && *r_cage) {
2176                         if ((*r_cage)->edit_btmesh == NULL) {
2177                                 if (*r_cage != *r_final) {
2178                                         BKE_mesh_tessface_ensure(*r_cage);
2179                                 }
2180                         }
2181                 }
2182         }
2183         /* --- */
2184
2185         /* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
2186         if (!do_loop_normals) {
2187                 mesh_ensure_display_normals(*r_final);
2188
2189                 /* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
2190                  * as they are used by display code when available (i.e. even if autosmooth is disabled). */
2191                 if (CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
2192                         CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
2193                 }
2194                 if (r_cage && CustomData_has_layer(&(*r_cage)->ldata, CD_NORMAL)) {
2195                         CustomData_free_layers(&(*r_cage)->ldata, CD_NORMAL, (*r_cage)->totloop);
2196                 }
2197         }
2198
2199         /* add an orco layer if needed */
2200         if (dataMask & CD_MASK_ORCO)
2201                 add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
2202
2203         if (me_orco) {
2204                 BKE_id_free(NULL, me_orco);
2205         }
2206
2207         if (deformedVerts) {
2208                 MEM_freeN(deformedVerts);
2209         }
2210 }
2211
2212 static void mesh_finalize_eval(Object *object)
2213 {
2214         Mesh *mesh = (Mesh *)object->data;
2215         Mesh *mesh_eval = object->runtime.mesh_eval;
2216         /* Special Tweaks for cases when evaluated mesh came from
2217          * BKE_mesh_new_nomain_from_template().
2218          */
2219         BLI_strncpy(mesh_eval->id.name, mesh->id.name, sizeof(mesh_eval->id.name));
2220         if (mesh_eval->mat != NULL) {
2221                 MEM_freeN(mesh_eval->mat);
2222         }
2223         /* Set flag which makes it easier to see what's going on in a debugger. */
2224         mesh_eval->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT;
2225         mesh_eval->mat = MEM_dupallocN(mesh->mat);
2226         mesh_eval->totcol = mesh->totcol;
2227         /* Make evaluated mesh to share same edit mesh pointer as original
2228          * and copied meshes.
2229          */
2230         mesh_eval->edit_btmesh = mesh->edit_btmesh;
2231         /* Copy autosmooth settings from original mesh.
2232          * This is not done by BKE_mesh_new_nomain_from_template(), so need to take
2233          * extra care here.
2234          */
2235         mesh_eval->flag |= (mesh->flag & ME_AUTOSMOOTH);
2236         mesh_eval->smoothresh = mesh->smoothresh;
2237         /* Replace evaluated object's data with fully evaluated mesh. */
2238         /* TODO(sergey): There was statement done by Sybren and Mai that this
2239          * caused modifiers to be applied twice. which is weirtd and shouldn't
2240          * really happen. But since there is no reference to the report, can not
2241          * do much about this.
2242          */
2243
2244         /* Object is sometimes not evaluated!
2245          * TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
2246         if (object->id.tag & LIB_TAG_COPIED_ON_WRITE) {
2247                 object->data = mesh_eval;
2248         }
2249         else {
2250                 /* evaluated will be available via: 'object->runtime.mesh_eval' */
2251         }
2252 }
2253
2254 static void mesh_build_data(
2255         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask,
2256         const bool build_shapekey_layers, const bool need_mapping)
2257 {
2258         BLI_assert(ob->type == OB_MESH);
2259
2260         BKE_object_free_derived_caches(ob);
2261         BKE_object_sculpt_modifiers_changed(ob);
2262
2263         mesh_calc_modifiers(
2264                 depsgraph, scene, ob, NULL, 1, need_mapping, dataMask, -1, true, build_shapekey_layers,
2265                 &ob->runtime.mesh_deform_eval, &ob->runtime.mesh_eval);
2266
2267         mesh_finalize_eval(ob);
2268
2269         ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, CD_MASK_MESH);
2270         ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, CD_MASK_MESH);
2271
2272         DM_set_object_boundbox(ob, ob->derivedFinal);
2273         /* TODO(sergey): Convert bounding box calculation to use mesh, then
2274          * we can skip this copy.
2275          */
2276         BKE_mesh_texspace_copy_from_object(ob->runtime.mesh_eval, ob);
2277
2278         ob->derivedFinal->needsFree = 0;
2279         ob->derivedDeform->needsFree = 0;
2280         ob->lastDataMask = dataMask;
2281         ob->lastNeedMapping = need_mapping;
2282
2283         if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
2284                 /* create PBVH immediately (would be created on the fly too,
2285                  * but this avoids waiting on first stroke) */
2286                 /* XXX Disabled for now.
2287                  * This can create horrible nasty bugs by generating re-entrant call of mesh_get_eval_final! */
2288 //              BKE_sculpt_update_mesh_elements(depsgraph, scene, scene->toolsettings->sculpt, ob, false, false);
2289         }
2290
2291         BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS));
2292 }
2293
2294 static void editbmesh_build_data(
2295         struct Depsgraph *depsgraph, Scene *scene,
2296         Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
2297 {
2298         BKE_object_free_derived_caches(obedit);
2299         BKE_object_sculpt_modifiers_changed(obedit);
2300
2301         BKE_editmesh_free_derivedmesh(em);
2302
2303         Mesh *me_cage;
2304         Mesh *me_final;
2305
2306         editbmesh_calc_modifiers(
2307                 depsgraph, scene, obedit, em, dataMask,
2308                 &me_cage, &me_final);
2309
2310         /* TODO(campbell): remove derived mesh conversion. */
2311         em->derivedFinal = CDDM_from_mesh_ex(me_final, CD_DUPLICATE, CD_MASK_MESH);
2312         BKE_id_free(NULL, me_final);
2313         if (me_cage != me_final) {
2314                 em->derivedCage = CDDM_from_mesh_ex(me_cage, CD_DUPLICATE, CD_MASK_MESH);
2315                 BKE_id_free(NULL, me_cage);
2316         }
2317         else {
2318                 em->derivedCage = em->derivedFinal;
2319         }
2320
2321         DM_set_object_boundbox(obedit, em->derivedFinal);
2322
2323         em->lastDataMask = dataMask;
2324         em->derivedFinal->needsFree = 0;
2325         em->derivedCage->needsFree = 0;
2326
2327         BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS));
2328 }
2329
2330 static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob, bool *r_need_mapping)
2331 {
2332         ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2333         Object *actob = view_layer->basact ? DEG_get_original_object(view_layer->basact->object) : NULL;
2334         CustomDataMask mask = ob->customdata_mask;
2335
2336         if (r_need_mapping) {
2337                 *r_need_mapping = false;
2338         }
2339
2340         if (DEG_get_original_object(ob) == actob) {
2341                 bool editing = BKE_paint_select_face_test(ob);
2342
2343                 /* weight paint and face select need original indices because of selection buffer drawing */
2344                 if (r_need_mapping) {
2345                         *r_need_mapping = (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT | OB_MODE_VERTEX_PAINT)));
2346                 }
2347
2348                 /* check if we need tfaces & mcols due to face select or texture paint */
2349                 if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
2350                         mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
2351                 }
2352
2353                 /* check if we need mcols due to vertex paint or weightpaint */
2354                 if (ob->mode & OB_MODE_VERTEX_PAINT) {
2355                         mask |= CD_MASK_MLOOPCOL;
2356                 }
2357
2358                 if (ob->mode & OB_MODE_EDIT)
2359                         mask |= CD_MASK_MVERT_SKIN;
2360         }
2361
2362         return mask;
2363 }
2364
2365 void makeDerivedMesh(
2366         struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
2367         CustomDataMask dataMask, const bool build_shapekey_layers)
2368 {
2369         bool need_mapping;
2370         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2371
2372         if (em) {
2373                 editbmesh_build_data(depsgraph, scene, ob, em, dataMask);
2374         }
2375         else {
2376                 mesh_build_data(depsgraph, scene, ob, dataMask, build_shapekey_layers, need_mapping);
2377         }
2378 }
2379
2380 /***/
2381
2382 #ifdef USE_DERIVEDMESH
2383 /* Deprecated DM, use: 'mesh_get_eval_final'. */
2384 DerivedMesh *mesh_get_derived_final(
2385         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2386 {
2387         /* if there's no derived mesh or the last data mask used doesn't include
2388          * the data we need, rebuild the derived mesh
2389          */
2390         bool need_mapping;
2391         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2392
2393         if (!ob->derivedFinal ||
2394             ((dataMask & ob->lastDataMask) != dataMask) ||
2395             (need_mapping != ob->lastNeedMapping))
2396         {
2397                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2398         }
2399
2400         if (ob->derivedFinal) { BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
2401         return ob->derivedFinal;
2402 }
2403 #endif
2404 Mesh *mesh_get_eval_final(
2405         struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2406 {
2407         /* if there's no evaluated mesh or the last data mask used doesn't include
2408          * the data we need, rebuild the derived mesh
2409          */
2410         bool need_mapping;
2411         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2412
2413         if (!ob->runtime.mesh_eval ||
2414             ((dataMask & ob->lastDataMask) != dataMask) ||
2415             (need_mapping != ob->lastNeedMapping))
2416         {
2417                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2418         }
2419
2420         if (ob->runtime.mesh_eval) { BLI_assert(!(ob->runtime.mesh_eval->runtime.cd_dirty_vert & CD_MASK_NORMAL)); }
2421         return ob->runtime.mesh_eval;
2422 }
2423
2424 #ifdef USE_DERIVEDMESH
2425 /* Deprecated DM, use: 'mesh_get_eval_deform' instead. */
2426 DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2427 {
2428         /* if there's no derived mesh or the last data mask used doesn't include
2429          * the data we need, rebuild the derived mesh
2430          */
2431         bool need_mapping;
2432
2433         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2434
2435         if (!ob->derivedDeform ||
2436             ((dataMask & ob->lastDataMask) != dataMask) ||
2437             (need_mapping != ob->lastNeedMapping))
2438         {
2439                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2440         }
2441
2442         return ob->derivedDeform;
2443 }
2444 #endif
2445 Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2446 {
2447         /* if there's no derived mesh or the last data mask used doesn't include
2448          * the data we need, rebuild the derived mesh
2449          */
2450         bool need_mapping;
2451
2452         dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
2453
2454         if (!ob->runtime.mesh_deform_eval ||
2455             ((dataMask & ob->lastDataMask) != dataMask) ||
2456             (need_mapping != ob->lastNeedMapping))
2457         {
2458                 mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
2459         }
2460
2461         return ob->runtime.mesh_deform_eval;
2462 }
2463
2464
2465 DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
2466 {
2467         DerivedMesh *final;
2468
2469         mesh_calc_modifiers_dm(
2470                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2471                 NULL, &final);
2472
2473         return final;
2474 }
2475
2476 #ifdef USE_DERIVEDMESH
2477 /* Deprecated, use `mesh_create_eval_final_index_render` instead. */
2478 DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask, int index)
2479 {
2480         DerivedMesh *final;
2481
2482         mesh_calc_modifiers_dm(
2483                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2484                 NULL, &final);
2485
2486         return final;
2487 }
2488 #endif
2489 struct Mesh *mesh_create_eval_final_index_render(
2490         struct Depsgraph *depsgraph, struct Scene *scene,
2491         struct Object *ob, CustomDataMask dataMask, int index)
2492 {
2493         Mesh *final;
2494
2495         mesh_calc_modifiers(
2496                 depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false,
2497                 NULL, &final);
2498
2499         return final;
2500 }
2501
2502 #ifdef USE_DERIVEDMESH
2503 /* Deprecated, use `mesh_create_eval_final_view` instead. */
2504 DerivedMesh *mesh_create_derived_view(
2505         struct Depsgraph *depsgraph, Scene *scene,
2506         Object *ob, CustomDataMask dataMask)
2507 {
2508         DerivedMesh *final;
2509
2510         /* XXX hack
2511          * psys modifier updates particle state when called during dupli-list generation,
2512          * which can lead to wrong transforms. This disables particle system modifier execution.
2513          */
2514         ob->transflag |= OB_NO_PSYS_UPDATE;
2515
2516         mesh_calc_modifiers_dm(
2517                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2518                 NULL, &final);
2519
2520         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2521
2522         return final;
2523 }
2524 #endif
2525
2526 Mesh *mesh_create_eval_final_view(
2527         struct Depsgraph *depsgraph, Scene *scene,
2528         Object *ob, CustomDataMask dataMask)
2529 {
2530         Mesh *final;
2531
2532         /* XXX hack
2533          * psys modifier updates particle state when called during dupli-list generation,
2534          * which can lead to wrong transforms. This disables particle system modifier execution.
2535          */
2536         ob->transflag |= OB_NO_PSYS_UPDATE;
2537
2538         mesh_calc_modifiers(
2539                 depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false,
2540                 NULL, &final);
2541
2542         ob->transflag &= ~OB_NO_PSYS_UPDATE;
2543
2544         return final;
2545 }
2546
2547 DerivedMesh *mesh_create_derived_no_deform(
2548         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
2549         float (*vertCos)[3], CustomDataMask dataMask)
2550 {
2551         DerivedMesh *final;
2552
2553         mesh_calc_modifiers_dm(
2554                 depsgraph, scene, ob, vertCos, 0, false, dataMask, -1, false, false,
2555                 NULL, &final);
2556
2557         return final;
2558 }
2559
2560 /***/
2561
2562 DerivedMesh *editbmesh_get_derived_cage_and_final(
2563         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2564         CustomDataMask dataMask,
2565         /* return args */
2566         DerivedMesh **r_final)
2567 {
2568         /* if there's no derived mesh or the last data mask used doesn't include
2569          * the data we need, rebuild the derived mesh
2570          */
2571         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2572
2573         if (!em->derivedCage ||
2574             (em->lastDataMask & dataMask) != dataMask)
2575         {
2576                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2577         }
2578
2579         *r_final = em->derivedFinal;
2580         if (em->derivedFinal) { BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
2581         return em->derivedCage;
2582 }
2583
2584 DerivedMesh *editbmesh_get_derived_cage(
2585         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
2586         CustomDataMask dataMask)
2587 {
2588         /* if there's no derived mesh or the last data mask used doesn't include
2589          * the data we need, rebuild the derived mesh
2590          */
2591         dataMask |= object_get_datamask(depsgraph, obedit, NULL);
2592
2593         if (!em->derivedCage ||
2594             (em->lastDataMask & dataMask) != dataMask)
2595         {
2596                 editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
2597         }
2598
2599         return em->derivedCage;
2600 }
2601
2602 /***/
2603
2604 /* get derived mesh from an object, using editbmesh if available. */
2605 DerivedMesh *object_get_derived_final(Object *ob, const bool for_render)
2606 {
2607         if (for_render) {
2608                 /* TODO(sergey): use proper derived render here in the future. */
2609                 return ob->derivedFinal;
2610         }
2611
2612         /* only return the editmesh if its from this object because
2613          * we don't a mesh from another object's modifier stack: T43122 */
2614         if (ob->type == OB_MESH) {
2615                 Mesh *me = ob->data;
2616                 BMEditMesh *em = me->edit_btmesh;
2617                 if (em && (em->ob == ob)) {
2618                         DerivedMesh *dm = em->derivedFinal;
2619                         return dm;
2620                 }
2621         }
2622
2623         return ob->derivedFinal;
2624 }
2625
2626
2627 /* UNUSED */
2628 #if 0
2629
2630 /* ********* For those who don't grasp derived stuff! (ton) :) *************** */
2631
2632 static void make_vertexcosnos__mapFunc(void *userData, int index, const float co[3],
2633                                        const float no_f[3], const short no_s[3])
2634 {
2635         DMCoNo *co_no = &((DMCoNo *)userData)[index];
2636
2637         /* check if we've been here before (normal should not be 0) */
2638         if (!is_zero_v3(co_no->no)) {
2639                 return;
2640         }
2641
2642         copy_v3_v3(co_no->co, co);
2643         if (no_f) {
2644                 copy_v3_v3(co_no->no, no_f);
2645         }
2646         else {
2647                 normal_short_to_float_v3(co_no->no, no_s);
2648         }
2649 }
2650
2651 /* always returns original amount me->totvert of vertices and normals, but fully deformed and subsurfered */
2652 /* this is needed for all code using vertexgroups (no subsurf support) */
2653 /* it stores the normals as floats, but they can still be scaled as shorts (32767 = unit) */
2654 /* in use now by vertex/weight paint and particle generating */
2655
2656 DMCoNo *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
2657 {
2658         Mesh *me = ob->data;
2659         DerivedMesh *dm;
2660         DMCoNo *vertexcosnos;
2661
2662         /* lets prevent crashing... */
2663         if (ob->type != OB_MESH || me->totvert == 0)
2664                 return NULL;
2665
2666         dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
2667
2668         if (dm->foreachMappedVert) {
2669                 vertexcosnos = MEM_calloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2670                 dm->foreachMappedVert(dm, make_vertexcosnos__mapFunc, vertexcosnos);
2671         }
2672         else {
2673                 DMCoNo *v_co_no = vertexcosnos = MEM_malloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
2674                 int a;
2675                 for (a = 0; a < me->totvert; a++, v_co_no++) {
2676                         dm->getVertCo(dm, a, v_co_no->co);
2677                         dm->getVertNo(dm, a, v_co_no->no);
2678                 }
2679         }
2680
2681         dm->release(dm);
2682         return vertexcosnos;
2683 }
2684
2685 #endif
2686
2687 /* same as above but for vert coords */
2688 typedef struct {
2689         float (*vertexcos)[3];
2690         BLI_bitmap *vertex_visit;
2691 } MappedUserData;
2692
2693 static void make_vertexcos__mapFunc(
2694         void *userData, int index, const float co[3],
2695         const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
2696 {
2697         MappedUserData *mappedData = (MappedUserData *)userData;
2698
2699         if (BLI_BITMAP_TEST(mappedData->vertex_visit, index) == 0) {
2700                 /* we need coord from prototype vertex, not from copies,
2701                  * assume they stored in the beginning of vertex array stored in DM
2702                  * (mirror modifier for eg does this) */
2703                 copy_v3_v3(mappedData->vertexcos[index], co);
2704                 BLI_BITMAP_ENABLE(mappedData->vertex_visit, index);
2705         }
2706 }
2707
2708 void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int totcos)
2709 {
2710         if (dm->foreachMappedVert) {
2711                 MappedUserData userData;
2712                 memset(r_cos, 0, sizeof(*r_cos) * totcos);
2713                 userData.vertexcos = r_cos;
2714                 userData.vertex_visit = BLI_BITMAP_NEW(totcos, "vertexcos flags");
2715                 dm->foreachMappedVert(dm, make_vertexcos__mapFunc, &userData, DM_FOREACH_NOP);
2716                 MEM_freeN(userData.vertex_visit);
2717         }
2718         else {
2719                 int i;
2720                 for (i = 0; i < totcos; i++) {
2721                         dm->getVertCo(dm, i, r_cos[i]);
2722                 }
2723         }
2724 }
2725
2726 void DM_add_named_tangent_layer_for_uv(
2727         CustomData *uv_data, CustomData *tan_data, int numLoopData,
2728         const char *layer_name)
2729 {
2730         if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
2731             CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
2732         {
2733                 CustomData_add_layer_named(
2734                         tan_data, CD_TANGENT, CD_CALLOC, NULL,
2735                         numLoopData, layer_name);
2736         }
2737 }
2738
2739 void DM_calc_loop_tangents(
2740         DerivedMesh *dm, bool calc_active_tangent,
2741         const char (*tangent_names)[MAX_NAME], int tangent_names_len)
2742 {
2743         BKE_mesh_calc_loop_tangent_ex(
2744                 dm->getVertArray(dm),
2745                 dm->getPolyArray(dm), dm->getNumPolys(dm),
2746                 dm->getLoopArray(dm),
2747                 dm->getLoopTriArray(dm), dm->getNumLoopTri(dm),
2748                 &dm->loopData,
2749                 calc_active_tangent,
2750                 tangent_names, tangent_names_len,
2751                 CustomData_get_layer(&dm->polyData, CD_NORMAL),
2752                 dm->getLoopDataArray(dm, CD_NORMAL),
2753                 dm->getVertDataArray(dm, CD_ORCO),  /* may be NULL */
2754                 /* result */
2755                 &dm->loopData, dm->getNumLoops(dm),
2756                 &dm->tangent_mask);
2757 }
2758
2759 /* Set object's bounding box based on DerivedMesh min/max data */
2760 void DM_set_object_boundbox(Object *ob, DerivedMesh *dm)
2761 {
2762         float min[3], max[3];
2763
2764         INIT_MINMAX(min, max);
2765         dm->getMinMax(dm, min, max);
2766
2767         if (!ob->bb)
2768                 ob->bb = MEM_callocN(sizeof(BoundBox), "DM-BoundBox");
2769
2770         BKE_boundbox_init_from_minmax(ob->bb, min, max);
2771
2772         ob->bb->flag &= ~BOUNDBOX_DIRTY;
2773 }
2774
2775 void DM_init_origspace(DerivedMesh *dm)
2776 {
2777         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2778
2779         OrigSpaceLoop *lof_array = CustomData_get_layer(&dm->loopData, CD_ORIGSPACE_MLOOP);
2780         const int numpoly = dm->getNumPolys(dm);
2781         // const int numloop = dm->getNumLoops(dm);
2782         MVert *mv = dm->getVertArray(dm);
2783         MLoop *ml = dm->getLoopArray(dm);
2784         MPoly *mp = dm->getPolyArray(dm);
2785         int i, j, k;
2786
2787         float (*vcos_2d)[2] = NULL;
2788         BLI_array_staticdeclare(vcos_2d, 64);
2789
2790         for (i = 0; i < numpoly; i++, mp++) {
2791                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2792
2793                 if (mp->totloop == 3 || mp->totloop == 4) {
2794                         for (j = 0; j < mp->totloop; j++, lof++) {
2795                                 copy_v2_v2(lof->uv, default_osf[j]);
2796                         }
2797                 }
2798                 else {
2799                         MLoop *l = &ml[mp->loopstart];
2800                         float p_nor[3], co[3];
2801                         float mat[3][3];
2802
2803                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2804                         float translate[2], scale[2];
2805
2806                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2807                         axis_dominant_v3_to_m3(mat, p_nor);
2808
2809                         BLI_array_clear(vcos_2d);
2810                         BLI_array_reserve(vcos_2d, mp->totloop);
2811                         for (j = 0; j < mp->totloop; j++, l++) {
2812                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2813                                 copy_v2_v2(vcos_2d[j], co);
2814
2815                                 for (k = 0; k < 2; k++) {
2816                                         if (co[k] > max[k])
2817                                                 max[k] = co[k];
2818                                         else if (co[k] < min[k])
2819                                                 min[k] = co[k];
2820                                 }
2821                         }
2822
2823                         /* Brings min to (0, 0). */
2824                         negate_v2_v2(translate, min);
2825
2826                         /* Scale will bring max to (1, 1). */
2827                         sub_v2_v2v2(scale, max, min);
2828                         if (scale[0] == 0.0f)
2829                                 scale[0] = 1e-9f;
2830                         if (scale[1] == 0.0f)
2831                                 scale[1] = 1e-9f;
2832                         invert_v2(scale);
2833
2834                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2835                         for (j = 0; j < mp->totloop; j++, lof++) {
2836                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2837                                 mul_v2_v2(lof->uv, scale);
2838                         }
2839                 }
2840         }
2841
2842         dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
2843         BLI_array_free(vcos_2d);
2844 }
2845
2846 static void mesh_init_origspace(Mesh *mesh)
2847 {
2848         const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
2849
2850         OrigSpaceLoop *lof_array = CustomData_get_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP);
2851         const int numpoly = mesh->totpoly;
2852         // const int numloop = mesh->totloop;
2853         MVert *mv = mesh->mvert;
2854         MLoop *ml = mesh->mloop;
2855         MPoly *mp = mesh->mpoly;
2856         int i, j, k;
2857
2858         float (*vcos_2d)[2] = NULL;
2859         BLI_array_staticdeclare(vcos_2d, 64);
2860
2861         for (i = 0; i < numpoly; i++, mp++) {
2862                 OrigSpaceLoop *lof = lof_array + mp->loopstart;
2863
2864                 if (mp->totloop == 3 || mp->totloop == 4) {
2865                         for (j = 0; j < mp->totloop; j++, lof++) {
2866                                 copy_v2_v2(lof->uv, default_osf[j]);
2867                         }
2868                 }
2869                 else {
2870                         MLoop *l = &ml[mp->loopstart];
2871                         float p_nor[3], co[3];
2872                         float mat[3][3];
2873
2874                         float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
2875                         float translate[2], scale[2];
2876
2877                         BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
2878                         axis_dominant_v3_to_m3(mat, p_nor);
2879
2880                         BLI_array_clear(vcos_2d);
2881                         BLI_array_reserve(vcos_2d, mp->totloop);
2882                         for (j = 0; j < mp->totloop; j++, l++) {
2883                                 mul_v3_m3v3(co, mat, mv[l->v].co);
2884                                 copy_v2_v2(vcos_2d[j], co);
2885
2886                                 for (k = 0; k < 2; k++) {
2887                                         if (co[k] > max[k])
2888                                                 max[k] = co[k];
2889                                         else if (co[k] < min[k])
2890                                                 min[k] = co[k];
2891                                 }
2892                         }
2893
2894                         /* Brings min to (0, 0). */
2895                         negate_v2_v2(translate, min);
2896
2897                         /* Scale will bring max to (1, 1). */
2898                         sub_v2_v2v2(scale, max, min);
2899                         if (scale[0] == 0.0f)
2900                                 scale[0] = 1e-9f;
2901                         if (scale[1] == 0.0f)
2902                                 scale[1] = 1e-9f;
2903                         invert_v2(scale);
2904
2905                         /* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assign them as origspace. */
2906                         for (j = 0; j < mp->totloop; j++, lof++) {
2907                                 add_v2_v2v2(lof->uv, vcos_2d[j], translate);
2908                                 mul_v2_v2(lof->uv, scale);
2909                         }
2910                 }
2911         }
2912
2913         BKE_mesh_tessface_clear(mesh);
2914         BLI_array_free(vcos_2d);
2915 }
2916
2917
2918 /* derivedmesh info printing function,
2919  * to help track down differences DM output */
2920
2921 #ifndef NDEBUG
2922 #include "BLI_dynstr.h"
2923
2924 static void dm_debug_info_layers(
2925         DynStr *dynstr, DerivedMesh *dm, CustomData *cd,
2926         void *(*getElemDataArray)(DerivedMesh *, int))
2927 {
2928         int type;
2929
2930         for (type = 0; type < CD_NUMTYPES; type++) {
2931                 if (CustomData_has_layer(cd, type)) {
2932                         /* note: doesn't account for multiple layers */
2933                         const char *name = CustomData_layertype_name(type);
2934                         const int size = CustomData_sizeof(type);
2935                         const void *pt = getElemDataArray(dm, type);
2936                         const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
2937                         const char *structname;
2938                         int structnum;
2939                         CustomData_file_write_info(type, &structname, &structnum);
2940                         BLI_dynstr_appendf(dynstr,
2941                                            "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
2942                                            name, structname, type, (const void *)pt, size, pt_size);
2943                 }
2944         }
2945 }
2946
2947 char *DM_debug_info(DerivedMesh *dm)
2948 {
2949         DynStr *dynstr = BLI_dynstr_new();
2950         char *ret;
2951         const char *tstr;
2952
2953         BLI_dynstr_appendf(dynstr, "{\n");
2954         BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)dm);
2955         switch (dm->type) {
2956                 case DM_TYPE_CDDM:     tstr = "DM_TYPE_CDDM";     break;
2957                 case DM_TYPE_CCGDM:    tstr = "DM_TYPE_CCGDM";     break;
2958                 default:               tstr = "UNKNOWN";           break;
2959         }
2960         BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
2961         BLI_dynstr_appendf(dynstr, "    'numVertData': %d,\n", dm->numVertData);
2962         BLI_dynstr_appendf(dynstr, "    'numEdgeData': %d,\n", dm->numEdgeData);
2963         BLI_dynstr_appendf(dynstr, "    'numTessFaceData': %d,\n", dm->numTessFaceData);
2964         BLI_dynstr_appendf(dynstr, "    'numPolyData': %d,\n", dm->numPolyData);
2965         BLI_dynstr_appendf(dynstr, "    'deformedOnly': %d,\n", dm->deformedOnly);
2966
2967         BLI_dynstr_appendf(dynstr, "    'vertexLayers': (\n");
2968         dm_debug_info_layers(dynstr, dm, &dm->vertData, dm->getVertDataArray);
2969         BLI_dynstr_appendf(dynstr, "    ),\n");
2970
2971         BLI_dynstr_appendf(dynstr, "    'edgeLayers': (\n");
2972         dm_debug_info_layers(dynstr, dm, &dm->edgeData, dm->getEdgeDataArray);
2973         BLI_dynstr_appendf(dynstr, "    ),\n");
2974
2975         BLI_dynstr_appendf(dynstr, "    'loopLayers': (\n");
2976         dm_debug_info_layers(dynstr, dm, &dm->loopData, dm->getLoopDataArray);
2977         BLI_dynstr_appendf(dynstr, "    ),\n");
2978
2979         BLI_dynstr_appendf(dynstr, "    'polyLayers': (\n");
2980         dm_debug_info_layers(dynstr, dm, &dm->polyData, dm->getPolyDataArray);
2981         BLI_dynstr_appendf(dynstr, "    ),\n");
2982
2983         BLI_dynstr_appendf(dynstr, "    'tessFaceLayers': (\n");
2984         dm_debug_info_layers(dynstr, dm, &dm->faceData, dm->getTessFaceDataArray);
2985         BLI_dynstr_appendf(dynstr, "    ),\n");
2986
2987         BLI_dynstr_appendf(dynstr, "}\n");
2988
2989         ret = BLI_dynstr_get_cstring(dynstr);
2990         BLI_dynstr_free(dynstr);
2991         return ret;
2992 }
2993
2994 void DM_debug_print(DerivedMesh *dm)
2995 {
2996         char *str = DM_debug_info(dm);
2997         puts(str);
2998         fflush(stdout);
2999         MEM_freeN(str);
3000 }
3001
3002 void DM_debug_print_cdlayers(CustomData *data)
3003 {
3004         int i;
3005         const CustomDataLayer *layer;
3006
3007         printf("{\n");
3008
3009         for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
3010
3011                 const char *name = CustomData_layertype_name(layer->type);
3012                 const int size = CustomData_sizeof(layer->type);
3013                 const char *structname;
3014                 int structnum;
3015                 CustomData_file_write_info(layer->type, &structname, &structnum);
3016                 printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
3017                        name, structname, layer->type, (const void *)layer->data, size, (int)(MEM_allocN_len(layer->data) / size));
3018         }
3019
3020         printf("}\n");
3021 }
3022
3023 bool DM_is_valid(DerivedMesh *dm)
3024 {
3025         const bool do_verbose = true;
3026         const bool do_fixes = false;
3027
3028         bool is_valid = true;
3029         bool changed = true;
3030
3031         is_valid &= BKE_mesh_validate_all_customdata(
3032                 dm->getVertDataLayout(dm),
3033                 dm->getEdgeDataLayout(dm),
3034                 dm->getLoopDataLayout(dm),
3035                 dm->getPolyDataLayout(dm),
3036                 false,  /* setting mask here isn't useful, gives false positives */
3037                 do_verbose, do_fixes, &changed);
3038
3039         is_valid &= BKE_mesh_validate_arrays(
3040                 NULL,
3041                 dm->getVertArray(dm), dm->getNumVerts(dm),
3042                 dm->getEdgeArray(dm), dm->getNumEdges(dm),
3043                 dm->getTessFaceArray(dm), dm->getNumTessFaces(dm),
3044                 dm->getLoopArray(dm), dm->getNumLoops(dm),
3045                 dm->getPolyArray(dm), dm->getNumPolys(dm),
3046                 dm->getVertDataArray(dm, CD_MDEFORMVERT),
3047                 do_verbose, do_fixes, &changed);
3048
3049         BLI_assert(changed == false);
3050
3051         return is_valid;
3052 }
3053
3054 #endif /* NDEBUG */
3055
3056 /* -------------------------------------------------------------------- */
3057
3058 MVert *DM_get_vert_array(DerivedMesh *dm, bool *allocated)
3059 {
3060         CustomData *vert_data = dm->getVertDataLayout(dm);
3061         MVert *mvert = CustomData_get_layer(vert_data, CD_MVERT);
3062         *allocated = false;
3063
3064         if (mvert == NULL) {
3065                 mvert = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(MVert), "dmvh vert data array");
3066                 dm->copyVertArray(dm, mvert);
3067                 *allocated = true;
3068         }
3069
3070         return mvert;
3071 }
3072
3073 MEdge *DM_get_edge_array(DerivedMesh *dm, bool *allocated)
3074 {
3075         CustomData *edge_data = dm->getEdgeDataLayout(dm);
3076         MEdge *medge = CustomData_get_layer(edge_data, CD_MEDGE);
3077         *allocated = false;
3078
3079         if (medge == NULL) {
3080                 medge = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(MEdge), "dm medge data array");
3081                 dm->copyEdgeArray(dm, medge);
3082                 *allocated = true;
3083         }
3084
3085         return medge;
3086 }
3087
3088 MLoop *DM_get_loop_array(DerivedMesh *dm, bool *r_allocated)
3089 {
3090         CustomData *loop_data = dm->getLoopDataLayout(dm);
3091         MLoop *mloop = CustomData_get_layer(loop_data, CD_MLOOP);
3092         *r_allocated = false;
3093
3094         if (mloop == NULL) {
3095                 mloop = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(MLoop), "dm loop data array");
3096                 dm->copyLoopArray(dm, mloop);
3097                 *r_allocated = true;
3098         }
3099
3100         return mloop;
3101 }
3102
3103 MPoly *DM_get_poly_array(DerivedMesh *dm, bool *r_allocated)
3104 {
3105         CustomData *poly_data = dm->getPolyDataLayout(dm);
3106         MPoly *mpoly = CustomData_get_layer(poly_data, CD_MPOLY);
3107         *r_allocated = false;
3108
3109         if (mpoly == NULL) {
3110                 mpoly = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(MPoly), "dm poly data array");
3111                 dm->copyPolyArray(dm, mpoly);
3112                 *r_allocated = true;
3113         }
3114
3115         return mpoly;
3116 }
3117
3118 MFace *DM_get_tessface_array(DerivedMesh *dm, bool *r_allocated)
3119 {
3120         CustomData *tessface_data = dm->getTessFaceDataLayout(dm);
3121         MFace *mface = CustomData_get_layer(tessface_data, CD_MFACE);
3122         *r_allocated = false;
3123
3124         if (mface == NULL) {
3125                 int numTessFaces = dm->getNumTessFaces(dm);
3126
3127                 if (numTessFaces > 0) {
3128                         mface = MEM_malloc_arrayN(numTessFaces, sizeof(MFace), "bvh mface data array");
3129                         dm->copyTessFaceArray(dm, mface);
3130                         *r_allocated = true;
3131                 }
3132         }
3133
3134         return mface;
3135 }