Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / cdderivedmesh.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) 2006 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Ben Batt <benbatt@gmail.com>
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  * Implementation of CDDerivedMesh.
28  *
29  * BKE_cdderivedmesh.h contains the function prototypes for this file.
30  *
31  */
32
33 /** \file blender/blenkernel/intern/cdderivedmesh.c
34  *  \ingroup bke
35  */
36
37 #include "atomic_ops.h"
38
39 #include "BLI_math.h"
40 #include "BLI_edgehash.h"
41 #include "BLI_utildefines.h"
42 #include "BLI_utildefines_stack.h"
43
44 #include "BKE_pbvh.h"
45 #include "BKE_cdderivedmesh.h"
46 #include "BKE_global.h"
47 #include "BKE_mesh.h"
48 #include "BKE_mesh_mapping.h"
49 #include "BKE_object.h"
50 #include "BKE_paint.h"
51 #include "BKE_editmesh.h"
52 #include "BKE_curve.h"
53
54 #include "DNA_mesh_types.h"
55 #include "DNA_meshdata_types.h"
56 #include "DNA_object_types.h"
57 #include "DNA_curve_types.h" /* for Curve */
58
59 #include "MEM_guardedalloc.h"
60
61 #include <string.h>
62 #include <limits.h>
63 #include <math.h>
64
65 typedef struct {
66         DerivedMesh dm;
67
68         /* these point to data in the DerivedMesh custom data layers,
69          * they are only here for efficiency and convenience **/
70         MVert *mvert;
71         MEdge *medge;
72         MFace *mface;
73         MLoop *mloop;
74         MPoly *mpoly;
75
76         /* Cached */
77         struct PBVH *pbvh;
78         bool pbvh_draw;
79
80         /* Mesh connectivity */
81         MeshElemMap *pmap;
82         int *pmap_mem;
83 } CDDerivedMesh;
84
85 /**************** DerivedMesh interface functions ****************/
86 static int cdDM_getNumVerts(DerivedMesh *dm)
87 {
88         return dm->numVertData;
89 }
90
91 static int cdDM_getNumEdges(DerivedMesh *dm)
92 {
93         return dm->numEdgeData;
94 }
95
96 static int cdDM_getNumTessFaces(DerivedMesh *dm)
97 {
98         /* uncomment and add a breakpoint on the printf()
99          * to help debug tessfaces issues since BMESH merge. */
100 #if 0
101         if (dm->numTessFaceData == 0 && dm->numPolyData != 0) {
102                 printf("%s: has no faces!, call DM_ensure_tessface() if you need them\n");
103         }
104 #endif
105         return dm->numTessFaceData;
106 }
107
108 static int cdDM_getNumLoops(DerivedMesh *dm)
109 {
110         return dm->numLoopData;
111 }
112
113 static int cdDM_getNumPolys(DerivedMesh *dm)
114 {
115         return dm->numPolyData;
116 }
117
118 static void cdDM_getVert(DerivedMesh *dm, int index, MVert *r_vert)
119 {
120         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
121         *r_vert = cddm->mvert[index];
122 }
123
124 static void cdDM_getEdge(DerivedMesh *dm, int index, MEdge *r_edge)
125 {
126         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
127         *r_edge = cddm->medge[index];
128 }
129
130 static void cdDM_getTessFace(DerivedMesh *dm, int index, MFace *r_face)
131 {
132         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
133         *r_face = cddm->mface[index];
134 }
135
136 static void cdDM_copyVertArray(DerivedMesh *dm, MVert *r_vert)
137 {
138         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
139         memcpy(r_vert, cddm->mvert, sizeof(*r_vert) * dm->numVertData);
140 }
141
142 static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *r_edge)
143 {
144         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
145         memcpy(r_edge, cddm->medge, sizeof(*r_edge) * dm->numEdgeData);
146 }
147
148 static void cdDM_copyTessFaceArray(DerivedMesh *dm, MFace *r_face)
149 {
150         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
151         memcpy(r_face, cddm->mface, sizeof(*r_face) * dm->numTessFaceData);
152 }
153
154 static void cdDM_copyLoopArray(DerivedMesh *dm, MLoop *r_loop)
155 {
156         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
157         memcpy(r_loop, cddm->mloop, sizeof(*r_loop) * dm->numLoopData);
158 }
159
160 static void cdDM_copyPolyArray(DerivedMesh *dm, MPoly *r_poly)
161 {
162         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
163         memcpy(r_poly, cddm->mpoly, sizeof(*r_poly) * dm->numPolyData);
164 }
165
166 static void cdDM_getMinMax(DerivedMesh *dm, float r_min[3], float r_max[3])
167 {
168         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
169         int i;
170
171         if (dm->numVertData) {
172                 for (i = 0; i < dm->numVertData; i++) {
173                         minmax_v3v3_v3(r_min, r_max, cddm->mvert[i].co);
174                 }
175         }
176         else {
177                 zero_v3(r_min);
178                 zero_v3(r_max);
179         }
180 }
181
182 static void cdDM_getVertCo(DerivedMesh *dm, int index, float r_co[3])
183 {
184         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
185
186         copy_v3_v3(r_co, cddm->mvert[index].co);
187 }
188
189 static void cdDM_getVertCos(DerivedMesh *dm, float (*r_cos)[3])
190 {
191         MVert *mv = CDDM_get_verts(dm);
192         int i;
193
194         for (i = 0; i < dm->numVertData; i++, mv++)
195                 copy_v3_v3(r_cos[i], mv->co);
196 }
197
198 static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
199 {
200         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
201         normal_short_to_float_v3(r_no, cddm->mvert[index].no);
202 }
203
204 static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm)
205 {
206         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
207
208         if (!cddm->pmap && ob->type == OB_MESH) {
209                 Mesh *me = ob->data;
210
211                 BKE_mesh_vert_poly_map_create(
212                         &cddm->pmap, &cddm->pmap_mem,
213                         me->mpoly, me->mloop,
214                         me->totvert, me->totpoly, me->totloop);
215         }
216
217         return cddm->pmap;
218 }
219
220 static bool check_sculpt_object_deformed(Object *object, bool for_construction)
221 {
222         bool deformed = false;
223
224         /* Active modifiers means extra deformation, which can't be handled correct
225          * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
226          * stuff and show final DerivedMesh so user would see actual object shape.
227          */
228         deformed |= object->sculpt->modifiers_active;
229
230         if (for_construction) {
231                 deformed |= object->sculpt->kb != NULL;
232         }
233         else {
234                 /* As in case with modifiers, we can't synchronize deformation made against
235                  * PBVH and non-locked keyblock, so also use PBVH only for brushes and
236                  * final DM to give final result to user.
237                  */
238                 deformed |= object->sculpt->kb && (object->shapeflag & OB_SHAPE_LOCK) == 0;
239         }
240
241         return deformed;
242 }
243
244 static bool can_pbvh_draw(Object *ob, DerivedMesh *dm)
245 {
246         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
247         Mesh *me = ob->data;
248         bool deformed = check_sculpt_object_deformed(ob, false);
249
250         if (deformed) {
251                 return false;
252         }
253
254         return cddm->mvert == me->mvert || ob->sculpt->kb;
255 }
256
257 static PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
258 {
259         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
260
261         if (!ob) {
262                 cddm->pbvh = NULL;
263                 return NULL;
264         }
265
266         if (!ob->sculpt)
267                 return NULL;
268
269         if (ob->sculpt->pbvh) {
270                 cddm->pbvh = ob->sculpt->pbvh;
271                 cddm->pbvh_draw = can_pbvh_draw(ob, dm);
272         }
273
274         /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH */
275         if (!cddm->pbvh && ob->sculpt->bm) {
276                 cddm->pbvh = BKE_pbvh_new();
277                 cddm->pbvh_draw = true;
278
279                 BKE_pbvh_build_bmesh(cddm->pbvh, ob->sculpt->bm,
280                                      ob->sculpt->bm_smooth_shading,
281                                      ob->sculpt->bm_log, ob->sculpt->cd_vert_node_offset,
282                                      ob->sculpt->cd_face_node_offset);
283
284                 pbvh_show_diffuse_color_set(cddm->pbvh, ob->sculpt->show_diffuse_color);
285                 pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
286         }
287                 
288
289         /* always build pbvh from original mesh, and only use it for drawing if
290          * this derivedmesh is just original mesh. it's the multires subsurf dm
291          * that this is actually for, to support a pbvh on a modified mesh */
292         if (!cddm->pbvh && ob->type == OB_MESH) {
293                 Mesh *me = BKE_object_get_original_mesh(ob);
294                 const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
295                 MLoopTri *looptri;
296                 bool deformed;
297
298                 cddm->pbvh = BKE_pbvh_new();
299                 cddm->pbvh_draw = can_pbvh_draw(ob, dm);
300
301                 looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
302
303                 BKE_mesh_recalc_looptri(
304                         me->mloop, me->mpoly,
305                         me->mvert,
306                         me->totloop, me->totpoly,
307                         looptri);
308                 
309                 BKE_pbvh_build_mesh(
310                         cddm->pbvh,
311                         me->mpoly, me->mloop,
312                         me->mvert, me->totvert, &me->vdata,
313                         looptri, looptris_num);
314
315                 pbvh_show_diffuse_color_set(cddm->pbvh, ob->sculpt->show_diffuse_color);
316                 pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
317
318                 deformed = check_sculpt_object_deformed(ob, true);
319
320                 if (deformed && ob->derivedDeform) {
321                         DerivedMesh *deformdm = ob->derivedDeform;
322                         float (*vertCos)[3];
323                         int totvert;
324
325                         totvert = deformdm->getNumVerts(deformdm);
326                         vertCos = MEM_malloc_arrayN(totvert, sizeof(float[3]), "cdDM_getPBVH vertCos");
327                         deformdm->getVertCos(deformdm, vertCos);
328                         BKE_pbvh_apply_vertCos(cddm->pbvh, vertCos);
329                         MEM_freeN(vertCos);
330                 }
331         }
332
333         return cddm->pbvh;
334 }
335
336 static void cdDM_foreachMappedVert(
337         DerivedMesh *dm,
338         void (*func)(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3]),
339         void *userData,
340         DMForeachFlag flag)
341 {
342         MVert *mv = CDDM_get_verts(dm);
343         const int *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
344         int i;
345
346         if (index) {
347                 for (i = 0; i < dm->numVertData; i++, mv++) {
348                         const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
349                         const int orig = *index++;
350                         if (orig == ORIGINDEX_NONE) continue;
351                         func(userData, orig, mv->co, NULL, no);
352                 }
353         }
354         else {
355                 for (i = 0; i < dm->numVertData; i++, mv++) {
356                         const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
357                         func(userData, i, mv->co, NULL, no);
358                 }
359         }
360 }
361
362 static void cdDM_foreachMappedEdge(
363         DerivedMesh *dm,
364         void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
365         void *userData)
366 {
367         CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
368         MVert *mv = cddm->mvert;
369         MEdge *med = cddm->medge;
370         int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
371
372         for (i = 0; i < dm->numEdgeData; i++, med++) {
373                 if (index) {
374                         orig = *index++;
375                         if (orig == ORIGINDEX_NONE) continue;
376                         func(userData, orig, mv[med->v1].co, mv[med->v2].co);
377                 }
378                 else
379                         func(userData, i, mv[med->v1].co, mv[med->v2].co);
380         }
381 }
382
383 static void cdDM_foreachMappedLoop(
384         DerivedMesh *dm,
385         void (*func)(void *userData, int vertex_index, int face_index, const float co[3], const float no[3]),
386         void *userData,
387         DMForeachFlag flag)
388 {
389         /* We can't use dm->getLoopDataLayout(dm) here, we want to always access dm->loopData, EditDerivedBMesh would
390          * return loop data from bmesh itself. */
391         const float (*lnors)[3] = (flag & DM_FOREACH_USE_NORMAL) ? DM_get_loop_data_layer(dm, CD_NORMAL) : NULL;
392
393         const MVert *mv = CDDM_get_verts(dm);
394         const MLoop *ml = CDDM_get_loops(dm);
395         const MPoly *mp = CDDM_get_polys(dm);
396         const int *v_index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
397         const int *f_index = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
398         int p_idx, i;
399
400         for (p_idx = 0; p_idx < dm->numPolyData; ++p_idx, ++mp) {
401                 for (i = 0; i < mp->totloop; ++i, ++ml) {
402                         const int v_idx = v_index ? v_index[ml->v] : ml->v;
403                         const int f_idx = f_index ? f_index[p_idx] : p_idx;
404                         const float *no = lnors ? *lnors++ : NULL;
405                         if (!ELEM(ORIGINDEX_NONE, v_idx, f_idx)) {
406                                 func(userData, v_idx, f_idx, mv[ml->v].co, no);
407                         }
408                 }
409         }
410 }
411
412 static void cdDM_foreachMappedFaceCenter(
413         DerivedMesh *dm,
414         void (*func)(void *userData, int index, const float cent[3], const float no[3]),
415         void *userData,
416         DMForeachFlag flag)
417 {
418         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
419         MVert *mvert = cddm->mvert;
420         MPoly *mp;
421         MLoop *ml;
422         int i, orig, *index;
423
424         index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
425         mp = cddm->mpoly;
426         for (i = 0; i < dm->numPolyData; i++, mp++) {
427                 float cent[3];
428                 float *no, _no[3];
429
430                 if (index) {
431                         orig = *index++;
432                         if (orig == ORIGINDEX_NONE) continue;
433                 }
434                 else {
435                         orig = i;
436                 }
437                 
438                 ml = &cddm->mloop[mp->loopstart];
439                 BKE_mesh_calc_poly_center(mp, ml, mvert, cent);
440
441                 if (flag & DM_FOREACH_USE_NORMAL) {
442                         BKE_mesh_calc_poly_normal(mp, ml, mvert, (no = _no));
443                 }
444                 else {
445                         no = NULL;
446                 }
447
448                 func(userData, orig, cent, no);
449         }
450
451 }
452
453 void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const bool do_face_nor_cpy)
454 {
455         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
456
457         dm->numTessFaceData = BKE_mesh_recalc_tessellation(
458                 &dm->faceData, &dm->loopData, &dm->polyData,
459                 cddm->mvert,
460                 dm->numTessFaceData, dm->numLoopData, dm->numPolyData,
461                 do_face_nor_cpy);
462
463         cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
464
465         /* Tessellation recreated faceData, and the active layer indices need to get re-propagated
466          * from loops and polys to faces */
467         CustomData_bmesh_update_active_layers(&dm->faceData, &dm->loopData);
468 }
469
470 void CDDM_recalc_tessellation(DerivedMesh *dm)
471 {
472         CDDM_recalc_tessellation_ex(dm, true);
473 }
474
475 void CDDM_recalc_looptri(DerivedMesh *dm)
476 {
477         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
478         const unsigned int totpoly = dm->numPolyData;
479         const unsigned int totloop = dm->numLoopData;
480
481         DM_ensure_looptri_data(dm);
482         BLI_assert(totpoly == 0 || cddm->dm.looptris.array_wip != NULL);
483
484         BKE_mesh_recalc_looptri(
485                 cddm->mloop, cddm->mpoly,
486                 cddm->mvert,
487                 totloop, totpoly,
488                 cddm->dm.looptris.array_wip);
489
490         BLI_assert(cddm->dm.looptris.array == NULL);
491         atomic_cas_ptr((void **)&cddm->dm.looptris.array, cddm->dm.looptris.array, cddm->dm.looptris.array_wip);
492         cddm->dm.looptris.array_wip = NULL;
493 }
494
495 static void cdDM_free_internal(CDDerivedMesh *cddm)
496 {
497         if (cddm->pmap) MEM_freeN(cddm->pmap);
498         if (cddm->pmap_mem) MEM_freeN(cddm->pmap_mem);
499 }
500
501 static void cdDM_release(DerivedMesh *dm)
502 {
503         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
504
505         if (DM_release(dm)) {
506                 cdDM_free_internal(cddm);
507                 MEM_freeN(cddm);
508         }
509 }
510
511 /**************** CDDM interface functions ****************/
512 static CDDerivedMesh *cdDM_create(const char *desc)
513 {
514         CDDerivedMesh *cddm;
515         DerivedMesh *dm;
516
517         cddm = MEM_callocN(sizeof(*cddm), desc);
518         dm = &cddm->dm;
519
520         dm->getMinMax = cdDM_getMinMax;
521
522         dm->getNumVerts = cdDM_getNumVerts;
523         dm->getNumEdges = cdDM_getNumEdges;
524         dm->getNumTessFaces = cdDM_getNumTessFaces;
525         dm->getNumLoops = cdDM_getNumLoops;
526         dm->getNumPolys = cdDM_getNumPolys;
527
528         dm->getVert = cdDM_getVert;
529         dm->getEdge = cdDM_getEdge;
530         dm->getTessFace = cdDM_getTessFace;
531
532         dm->copyVertArray = cdDM_copyVertArray;
533         dm->copyEdgeArray = cdDM_copyEdgeArray;
534         dm->copyTessFaceArray = cdDM_copyTessFaceArray;
535         dm->copyLoopArray = cdDM_copyLoopArray;
536         dm->copyPolyArray = cdDM_copyPolyArray;
537
538         dm->getVertData = DM_get_vert_data;
539         dm->getEdgeData = DM_get_edge_data;
540         dm->getTessFaceData = DM_get_tessface_data;
541         dm->getVertDataArray = DM_get_vert_data_layer;
542         dm->getEdgeDataArray = DM_get_edge_data_layer;
543         dm->getTessFaceDataArray = DM_get_tessface_data_layer;
544
545         dm->calcNormals = CDDM_calc_normals;
546         dm->calcLoopNormals = CDDM_calc_loop_normals;
547         dm->calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
548         dm->calcLoopTangents = DM_calc_loop_tangents;
549         dm->recalcTessellation = CDDM_recalc_tessellation;
550         dm->recalcLoopTri = CDDM_recalc_looptri;
551
552         dm->getVertCos = cdDM_getVertCos;
553         dm->getVertCo = cdDM_getVertCo;
554         dm->getVertNo = cdDM_getVertNo;
555
556         dm->getPBVH = cdDM_getPBVH;
557         dm->getPolyMap = cdDM_getPolyMap;
558
559         dm->foreachMappedVert = cdDM_foreachMappedVert;
560         dm->foreachMappedEdge = cdDM_foreachMappedEdge;
561         dm->foreachMappedLoop = cdDM_foreachMappedLoop;
562         dm->foreachMappedFaceCenter = cdDM_foreachMappedFaceCenter;
563
564         dm->release = cdDM_release;
565
566         return cddm;
567 }
568
569 DerivedMesh *CDDM_new(int numVerts, int numEdges, int numTessFaces, int numLoops, int numPolys)
570 {
571         CDDerivedMesh *cddm = cdDM_create("CDDM_new dm");
572         DerivedMesh *dm = &cddm->dm;
573
574         DM_init(dm, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys);
575
576         CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
577         CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
578         CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
579         CustomData_add_layer(&dm->polyData, CD_ORIGINDEX, CD_CALLOC, NULL, numPolys);
580
581         CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
582         CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
583         CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
584         CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
585         CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
586
587         cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
588         cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
589         cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
590         cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
591         cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
592
593         return dm;
594 }
595
596 DerivedMesh *CDDM_from_mesh(Mesh *mesh)
597 {
598         return CDDM_from_mesh_ex(mesh, CD_REFERENCE, CD_MASK_MESH);
599 }
600
601 DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh, eCDAllocType alloctype, CustomDataMask mask)
602 {
603         CDDerivedMesh *cddm = cdDM_create(__func__);
604         DerivedMesh *dm = &cddm->dm;
605
606         mask &= ~CD_MASK_MDISPS;
607
608         /* this does a referenced copy, with an exception for fluidsim */
609
610         DM_init(dm, DM_TYPE_CDDM, mesh->totvert, mesh->totedge, 0 /* mesh->totface */,
611                 mesh->totloop, mesh->totpoly);
612
613         /* This should actually be dm->deformedOnly = mesh->runtime.deformed_only,
614          * but only if the original mesh had its deformed_only flag correctly set
615          * (which isn't generally the case). */
616         dm->deformedOnly = 1;
617         dm->cd_flag = mesh->cd_flag;
618
619         if (mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL) {
620                 dm->dirty |= DM_DIRTY_NORMALS;
621         }
622         /* TODO DM_DIRTY_TESS_CDLAYERS ? Maybe not though, since we probably want to switch to looptris ? */
623
624         CustomData_merge(&mesh->vdata, &dm->vertData, mask, alloctype,
625                          mesh->totvert);
626         CustomData_merge(&mesh->edata, &dm->edgeData, mask, alloctype,
627                          mesh->totedge);
628         CustomData_merge(&mesh->fdata, &dm->faceData, mask | CD_MASK_ORIGINDEX, alloctype,
629                          0 /* mesh->totface */);
630         CustomData_merge(&mesh->ldata, &dm->loopData, mask, alloctype,
631                          mesh->totloop);
632         CustomData_merge(&mesh->pdata, &dm->polyData, mask, alloctype,
633                          mesh->totpoly);
634
635         cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
636         cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
637         cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
638         cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
639 #if 0
640         cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
641 #else
642         cddm->mface = NULL;
643 #endif
644
645         /* commented since even when CD_ORIGINDEX was first added this line fails
646          * on the default cube, (after editmode toggle too) - campbell */
647 #if 0
648         BLI_assert(CustomData_has_layer(&cddm->dm.faceData, CD_ORIGINDEX));
649 #endif
650
651         return dm;
652 }
653
654 DerivedMesh *CDDM_from_curve(Object *ob)
655 {
656         ListBase disp = {NULL, NULL};
657
658         if (ob->curve_cache) {
659                 disp = ob->curve_cache->disp;
660         }
661
662         return CDDM_from_curve_displist(ob, &disp);
663 }
664
665 DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
666 {
667         Curve *cu = (Curve *) ob->data;
668         DerivedMesh *dm;
669         CDDerivedMesh *cddm;
670         MVert *allvert;
671         MEdge *alledge;
672         MLoop *allloop;
673         MPoly *allpoly;
674         MLoopUV *alluv = NULL;
675         int totvert, totedge, totloop, totpoly;
676         bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
677
678         if (BKE_mesh_nurbs_displist_to_mdata(
679                 ob, dispbase, &allvert, &totvert, &alledge,
680                 &totedge, &allloop, &allpoly, (use_orco_uv) ? &alluv : NULL,
681                 &totloop, &totpoly) != 0)
682         {
683                 /* Error initializing mdata. This often happens when curve is empty */
684                 return CDDM_new(0, 0, 0, 0, 0);
685         }
686
687         dm = CDDM_new(totvert, totedge, 0, totloop, totpoly);
688         dm->deformedOnly = 1;
689         dm->dirty |= DM_DIRTY_NORMALS;
690
691         cddm = (CDDerivedMesh *)dm;
692
693         memcpy(cddm->mvert, allvert, totvert * sizeof(MVert));
694         memcpy(cddm->medge, alledge, totedge * sizeof(MEdge));
695         memcpy(cddm->mloop, allloop, totloop * sizeof(MLoop));
696         memcpy(cddm->mpoly, allpoly, totpoly * sizeof(MPoly));
697
698         if (alluv) {
699                 const char *uvname = "Orco";
700                 CustomData_add_layer_named(&cddm->dm.loopData, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
701         }
702
703         MEM_freeN(allvert);
704         MEM_freeN(alledge);
705         MEM_freeN(allloop);
706         MEM_freeN(allpoly);
707
708         return dm;
709 }
710
711 static void loops_to_customdata_corners(
712         BMesh *bm, CustomData *facedata,
713         int cdindex, const BMLoop *l3[3],
714         int numCol, int numUV)
715 {
716         const BMLoop *l;
717 //      BMFace *f = l3[0]->f;
718         MTFace *texface;
719         MCol *mcol;
720         MLoopCol *mloopcol;
721         MLoopUV *mloopuv;
722         int i, j, hasPCol = CustomData_has_layer(&bm->ldata, CD_PREVIEW_MLOOPCOL);
723
724         for (i = 0; i < numUV; i++) {
725                 texface = CustomData_get_n(facedata, CD_MTFACE, cdindex, i);
726         
727                 for (j = 0; j < 3; j++) {
728                         l = l3[j];
729                         mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i);
730                         copy_v2_v2(texface->uv[j], mloopuv->uv);
731                 }
732         }
733
734         for (i = 0; i < numCol; i++) {
735                 mcol = CustomData_get_n(facedata, CD_MCOL, cdindex, i);
736                 
737                 for (j = 0; j < 3; j++) {
738                         l = l3[j];
739                         mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPCOL, i);
740                         MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
741                 }
742         }
743
744         if (hasPCol) {
745                 mcol = CustomData_get(facedata, cdindex, CD_PREVIEW_MCOL);
746
747                 for (j = 0; j < 3; j++) {
748                         l = l3[j];
749                         mloopcol = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_PREVIEW_MLOOPCOL);
750                         MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
751                 }
752         }
753 }
754
755 /* used for both editbmesh and bmesh */
756 static DerivedMesh *cddm_from_bmesh_ex(
757         struct BMesh *bm, const bool use_mdisps,
758         /* EditBMesh vars for use_tessface */
759         const bool use_tessface,
760         const int em_tottri, const BMLoop *(*em_looptris)[3])
761 {
762         DerivedMesh *dm = CDDM_new(bm->totvert,
763                                    bm->totedge,
764                                    use_tessface ? em_tottri : 0,
765                                    bm->totloop,
766                                    bm->totface);
767
768         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
769         BMIter iter;
770         BMVert *eve;
771         BMEdge *eed;
772         BMFace *efa;
773         MVert *mvert = cddm->mvert;
774         MEdge *medge = cddm->medge;
775         MFace *mface = cddm->mface;
776         MLoop *mloop = cddm->mloop;
777         MPoly *mpoly = cddm->mpoly;
778         int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
779         int numUV  = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
780         int *index, add_orig;
781         CustomDataMask mask;
782         unsigned int i, j;
783         
784         const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
785         const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
786         const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
787         
788         dm->deformedOnly = 1;
789         
790         /* don't add origindex layer if one already exists */
791         add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
792
793         mask = use_mdisps ? CD_MASK_DERIVEDMESH | CD_MASK_MDISPS : CD_MASK_DERIVEDMESH;
794         
795         /* don't process shapekeys, we only feed them through the modifier stack as needed,
796          * e.g. for applying modifiers or the like*/
797         mask &= ~CD_MASK_SHAPEKEY;
798         CustomData_merge(&bm->vdata, &dm->vertData, mask,
799                          CD_CALLOC, dm->numVertData);
800         CustomData_merge(&bm->edata, &dm->edgeData, mask,
801                          CD_CALLOC, dm->numEdgeData);
802         CustomData_merge(&bm->ldata, &dm->loopData, mask,
803                          CD_CALLOC, dm->numLoopData);
804         CustomData_merge(&bm->pdata, &dm->polyData, mask,
805                          CD_CALLOC, dm->numPolyData);
806
807         /* add tessellation mface layers */
808         if (use_tessface) {
809                 CustomData_from_bmeshpoly(&dm->faceData, &dm->loopData, em_tottri);
810         }
811
812         index = dm->getVertDataArray(dm, CD_ORIGINDEX);
813
814         BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
815                 MVert *mv = &mvert[i];
816
817                 copy_v3_v3(mv->co, eve->co);
818
819                 BM_elem_index_set(eve, i); /* set_inline */
820
821                 normal_float_to_short_v3(mv->no, eve->no);
822
823                 mv->flag = BM_vert_flag_to_mflag(eve);
824
825                 if (cd_vert_bweight_offset != -1) mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
826
827                 if (add_orig) *index++ = i;
828
829                 CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
830         }
831         bm->elem_index_dirty &= ~BM_VERT;
832
833         index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
834         BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
835                 MEdge *med = &medge[i];
836
837                 BM_elem_index_set(eed, i); /* set_inline */
838
839                 med->v1 = BM_elem_index_get(eed->v1);
840                 med->v2 = BM_elem_index_get(eed->v2);
841
842                 med->flag = BM_edge_flag_to_mflag(eed);
843
844                 /* handle this differently to editmode switching,
845                  * only enable draw for single user edges rather then calculating angle */
846                 if ((med->flag & ME_EDGEDRAW) == 0) {
847                         if (eed->l && eed->l == eed->l->radial_next) {
848                                 med->flag |= ME_EDGEDRAW;
849                         }
850                 }
851
852                 if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
853                 if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
854
855                 CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
856                 if (add_orig) *index++ = i;
857         }
858         bm->elem_index_dirty &= ~BM_EDGE;
859
860         /* avoid this where possiblem, takes extra memory */
861         if (use_tessface) {
862
863                 BM_mesh_elem_index_ensure(bm, BM_FACE);
864
865                 index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
866                 for (i = 0; i < dm->numTessFaceData; i++) {
867                         MFace *mf = &mface[i];
868                         const BMLoop **l = em_looptris[i];
869                         efa = l[0]->f;
870
871                         mf->v1 = BM_elem_index_get(l[0]->v);
872                         mf->v2 = BM_elem_index_get(l[1]->v);
873                         mf->v3 = BM_elem_index_get(l[2]->v);
874                         mf->v4 = 0;
875                         mf->mat_nr = efa->mat_nr;
876                         mf->flag = BM_face_flag_to_mflag(efa);
877
878                         /* map mfaces to polygons in the same cddm intentionally */
879                         *index++ = BM_elem_index_get(efa);
880
881                         loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numUV);
882                         test_index_face(mf, &dm->faceData, i, 3);
883                 }
884         }
885         
886         index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
887         j = 0;
888         BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
889                 BMLoop *l_iter;
890                 BMLoop *l_first;
891                 MPoly *mp = &mpoly[i];
892
893                 BM_elem_index_set(efa, i); /* set_inline */
894
895                 mp->totloop = efa->len;
896                 mp->flag = BM_face_flag_to_mflag(efa);
897                 mp->loopstart = j;
898                 mp->mat_nr = efa->mat_nr;
899
900                 l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
901                 do {
902                         mloop->v = BM_elem_index_get(l_iter->v);
903                         mloop->e = BM_elem_index_get(l_iter->e);
904                         CustomData_from_bmesh_block(&bm->ldata, &dm->loopData, l_iter->head.data, j);
905
906                         BM_elem_index_set(l_iter, j); /* set_inline */
907
908                         j++;
909                         mloop++;
910                 } while ((l_iter = l_iter->next) != l_first);
911
912                 CustomData_from_bmesh_block(&bm->pdata, &dm->polyData, efa->head.data, i);
913
914                 if (add_orig) *index++ = i;
915         }
916         bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
917
918         dm->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
919
920         return dm;
921 }
922
923 struct DerivedMesh *CDDM_from_bmesh(struct BMesh *bm, const bool use_mdisps)
924 {
925         return cddm_from_bmesh_ex(
926                 bm, use_mdisps, false,
927                 /* these vars are for editmesh only */
928                 0, NULL);
929 }
930
931 DerivedMesh *CDDM_from_editbmesh(BMEditMesh *em, const bool use_mdisps, const bool use_tessface)
932 {
933         return cddm_from_bmesh_ex(
934                 em->bm, use_mdisps,
935                 /* editmesh */
936                 use_tessface, em->tottri, (const BMLoop *(*)[3])em->looptris);
937 }
938
939 static DerivedMesh *cddm_copy_ex(DerivedMesh *source,
940                                  const bool need_tessface_data,
941                                  const bool faces_from_tessfaces)
942 {
943         const bool copy_tessface_data = (faces_from_tessfaces || need_tessface_data);
944         CDDerivedMesh *cddm = cdDM_create("CDDM_copy cddm");
945         DerivedMesh *dm = &cddm->dm;
946         int numVerts = source->numVertData;
947         int numEdges = source->numEdgeData;
948         int numTessFaces = copy_tessface_data ? source->numTessFaceData : 0;
949         int numLoops = source->numLoopData;
950         int numPolys = source->numPolyData;
951
952         /* NOTE: Don't copy tessellation faces if not requested explicitly. */
953
954         /* ensure these are created if they are made on demand */
955         source->getVertDataArray(source, CD_ORIGINDEX);
956         source->getEdgeDataArray(source, CD_ORIGINDEX);
957         source->getPolyDataArray(source, CD_ORIGINDEX);
958         if (copy_tessface_data) {
959                 source->getTessFaceDataArray(source, CD_ORIGINDEX);
960         }
961
962         /* this initializes dm, and copies all non mvert/medge/mface layers */
963         DM_from_template(dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces,
964                          numLoops, numPolys);
965         dm->deformedOnly = source->deformedOnly;
966         dm->cd_flag = source->cd_flag;
967         dm->dirty = source->dirty;
968
969         /* Tessellation data is never copied, so tag it here.
970          * Only tag dirty layers if we really ignored tessellation faces.
971          */
972         if (!copy_tessface_data) {
973                 dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
974         }
975
976         CustomData_copy_data(&source->vertData, &dm->vertData, 0, 0, numVerts);
977         CustomData_copy_data(&source->edgeData, &dm->edgeData, 0, 0, numEdges);
978         if (copy_tessface_data) {
979                 CustomData_copy_data(&source->faceData, &dm->faceData, 0, 0, numTessFaces);
980         }
981
982         /* now add mvert/medge/mface layers */
983         cddm->mvert = source->dupVertArray(source);
984         cddm->medge = source->dupEdgeArray(source);
985
986         CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, cddm->mvert, numVerts);
987         CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, cddm->medge, numEdges);
988
989         if (faces_from_tessfaces || copy_tessface_data) {
990                 cddm->mface = source->dupTessFaceArray(source);
991                 CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, cddm->mface, numTessFaces);
992         }
993
994         if (!faces_from_tessfaces) {
995                 DM_DupPolys(source, dm);
996         }
997         else {
998                 CDDM_tessfaces_to_faces(dm);
999         }
1000
1001         cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1002         cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1003
1004         return dm;
1005 }
1006
1007 DerivedMesh *CDDM_copy(DerivedMesh *source)
1008 {
1009         return cddm_copy_ex(source, false, false);
1010 }
1011
1012 DerivedMesh *CDDM_copy_from_tessface(DerivedMesh *source)
1013 {
1014         return cddm_copy_ex(source, false, true);
1015 }
1016
1017 DerivedMesh *CDDM_copy_with_tessface(DerivedMesh *source)
1018 {
1019         return cddm_copy_ex(source, true, false);
1020 }
1021
1022 /* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
1023  * relationship between mesh data this needs to be set by the caller. */
1024 DerivedMesh *CDDM_from_template_ex(
1025         DerivedMesh *source,
1026         int numVerts, int numEdges, int numTessFaces,
1027         int numLoops, int numPolys,
1028         CustomDataMask mask)
1029 {
1030         CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
1031         DerivedMesh *dm = &cddm->dm;
1032
1033         /* ensure these are created if they are made on demand */
1034         source->getVertDataArray(source, CD_ORIGINDEX);
1035         source->getEdgeDataArray(source, CD_ORIGINDEX);
1036         source->getTessFaceDataArray(source, CD_ORIGINDEX);
1037         source->getPolyDataArray(source, CD_ORIGINDEX);
1038
1039         /* this does a copy of all non mvert/medge/mface layers */
1040         DM_from_template_ex(
1041                 dm, source, DM_TYPE_CDDM,
1042                 numVerts, numEdges, numTessFaces,
1043                 numLoops, numPolys,
1044                 mask);
1045
1046         /* now add mvert/medge/mface layers */
1047         CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
1048         CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
1049         CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
1050         CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
1051         CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
1052
1053         if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX))
1054                 CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
1055         if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX))
1056                 CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
1057         if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX))
1058                 CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
1059
1060         cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
1061         cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
1062         cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
1063         cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1064         cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1065
1066         return dm;
1067 }
1068 DerivedMesh *CDDM_from_template(
1069         DerivedMesh *source,
1070         int numVerts, int numEdges, int numTessFaces,
1071         int numLoops, int numPolys)
1072 {
1073         return CDDM_from_template_ex(
1074                 source, numVerts, numEdges, numTessFaces,
1075                 numLoops, numPolys,
1076                 CD_MASK_DERIVEDMESH);
1077 }
1078
1079 void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
1080 {
1081         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1082         MVert *vert;
1083         int i;
1084
1085         /* this will just return the pointer if it wasn't a referenced layer */
1086         vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1087         cddm->mvert = vert;
1088
1089         for (i = 0; i < dm->numVertData; ++i, ++vert)
1090                 copy_v3_v3(vert->co, vertCoords[i]);
1091
1092         cddm->dm.dirty |= DM_DIRTY_NORMALS;
1093 }
1094
1095 void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3])
1096 {
1097         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1098         MVert *vert;
1099         int i;
1100
1101         /* this will just return the pointer if it wasn't a referenced layer */
1102         vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1103         cddm->mvert = vert;
1104
1105         for (i = 0; i < dm->numVertData; ++i, ++vert)
1106                 copy_v3_v3_short(vert->no, vertNormals[i]);
1107
1108         cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1109 }
1110
1111 void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const bool only_face_normals)
1112 {
1113         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1114         float (*face_nors)[3] = NULL;
1115
1116         if (dm->numVertData == 0) {
1117                 cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1118                 return;
1119         }
1120
1121         /* now we skip calculating vertex normals for referenced layer,
1122          * no need to duplicate verts.
1123          * WATCH THIS, bmesh only change!,
1124          * need to take care of the side effects here - campbell */
1125 #if 0
1126         /* we don't want to overwrite any referenced layers */
1127         cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1128 #endif
1129
1130 #if 0
1131         if (dm->numTessFaceData == 0) {
1132                 /* No tessellation on this mesh yet, need to calculate one.
1133                  *
1134                  * Important not to update face normals from polys since it
1135                  * interferes with assigning the new normal layer in the following code.
1136                  */
1137                 CDDM_recalc_tessellation_ex(dm, false);
1138         }
1139         else {
1140                 /* A tessellation already exists, it should always have a CD_ORIGINDEX */
1141                 BLI_assert(CustomData_has_layer(&dm->faceData, CD_ORIGINDEX));
1142                 CustomData_free_layers(&dm->faceData, CD_NORMAL, dm->numTessFaceData);
1143         }
1144 #endif
1145
1146         face_nors = MEM_malloc_arrayN(dm->numPolyData, sizeof(*face_nors), "face_nors");
1147
1148         /* calculate face normals */
1149         BKE_mesh_calc_normals_poly(
1150                 cddm->mvert, NULL, dm->numVertData, CDDM_get_loops(dm), CDDM_get_polys(dm),
1151                 dm->numLoopData, dm->numPolyData, face_nors,
1152                 only_face_normals);
1153
1154         CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_ASSIGN, face_nors, dm->numPolyData);
1155
1156         cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1157 }
1158
1159 void CDDM_calc_normals_mapping(DerivedMesh *dm)
1160 {
1161         /* use this to skip calculating normals on original vert's, this may need to be changed */
1162         const bool only_face_normals = CustomData_is_referenced_layer(&dm->vertData, CD_MVERT);
1163
1164         CDDM_calc_normals_mapping_ex(dm, only_face_normals);
1165 }
1166
1167 #if 0
1168 /* bmesh note: this matches what we have in trunk */
1169 void CDDM_calc_normals(DerivedMesh *dm)
1170 {
1171         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1172         float (*poly_nors)[3];
1173
1174         if (dm->numVertData == 0) return;
1175
1176         /* we don't want to overwrite any referenced layers */
1177         cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1178
1179         /* fill in if it exists */
1180         poly_nors = CustomData_get_layer(&dm->polyData, CD_NORMAL);
1181         if (!poly_nors) {
1182                 poly_nors = CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_CALLOC, NULL, dm->numPolyData);
1183         }
1184
1185         BKE_mesh_calc_normals_poly(cddm->mvert, dm->numVertData, CDDM_get_loops(dm), CDDM_get_polys(dm),
1186                                        dm->numLoopData, dm->numPolyData, poly_nors, false);
1187
1188         cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1189 }
1190 #else
1191
1192 /* poly normal layer is now only for final display */
1193 void CDDM_calc_normals(DerivedMesh *dm)
1194 {
1195         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1196
1197         /* we don't want to overwrite any referenced layers */
1198         cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1199
1200         BKE_mesh_calc_normals_poly(cddm->mvert, NULL, dm->numVertData, CDDM_get_loops(dm), CDDM_get_polys(dm),
1201                                    dm->numLoopData, dm->numPolyData, NULL, false);
1202
1203         cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1204 }
1205
1206 #endif
1207
1208 void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
1209 {
1210         CDDM_calc_loop_normals_spacearr(dm, use_split_normals, split_angle, NULL);
1211 }
1212
1213 /* #define DEBUG_CLNORS */
1214 #ifdef DEBUG_CLNORS
1215 #  include "BLI_linklist.h"
1216 #endif
1217
1218 void CDDM_calc_loop_normals_spacearr(
1219         DerivedMesh *dm, const bool use_split_normals, const float split_angle, MLoopNorSpaceArray *r_lnors_spacearr)
1220 {
1221         MVert *mverts = dm->getVertArray(dm);
1222         MEdge *medges = dm->getEdgeArray(dm);
1223         MLoop *mloops = dm->getLoopArray(dm);
1224         MPoly *mpolys = dm->getPolyArray(dm);
1225
1226         CustomData *ldata, *pdata;
1227
1228         float (*lnors)[3];
1229         short (*clnor_data)[2];
1230         float (*pnors)[3];
1231
1232         const int numVerts = dm->getNumVerts(dm);
1233         const int numEdges = dm->getNumEdges(dm);
1234         const int numLoops = dm->getNumLoops(dm);
1235         const int numPolys = dm->getNumPolys(dm);
1236
1237         ldata = dm->getLoopDataLayout(dm);
1238         if (CustomData_has_layer(ldata, CD_NORMAL)) {
1239                 lnors = CustomData_get_layer(ldata, CD_NORMAL);
1240         }
1241         else {
1242                 lnors = CustomData_add_layer(ldata, CD_NORMAL, CD_CALLOC, NULL, numLoops);
1243         }
1244
1245         /* Compute poly (always needed) and vert normals. */
1246         /* Note we can't use DM_ensure_normals, since it won't keep computed poly nors... */
1247         pdata = dm->getPolyDataLayout(dm);
1248         pnors = CustomData_get_layer(pdata, CD_NORMAL);
1249         if (!pnors) {
1250                 pnors = CustomData_add_layer(pdata, CD_NORMAL, CD_CALLOC, NULL, numPolys);
1251         }
1252         BKE_mesh_calc_normals_poly(mverts, NULL, numVerts, mloops, mpolys, numLoops, numPolys, pnors,
1253                                    (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
1254
1255         dm->dirty &= ~DM_DIRTY_NORMALS;
1256
1257         clnor_data = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
1258
1259         BKE_mesh_normals_loop_split(mverts, numVerts, medges, numEdges, mloops, lnors, numLoops,
1260                                     mpolys, (const float (*)[3])pnors, numPolys,
1261                                     use_split_normals, split_angle,
1262                                     r_lnors_spacearr, clnor_data, NULL);
1263 #ifdef DEBUG_CLNORS
1264         if (r_lnors_spacearr) {
1265                 int i;
1266                 for (i = 0; i < numLoops; i++) {
1267                         if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
1268                                 LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
1269                                 printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
1270                                 print_v3("\tfinal lnor", lnors[i]);
1271                                 print_v3("\tauto lnor", r_lnors_spacearr->lspacearr[i]->vec_lnor);
1272                                 print_v3("\tref_vec", r_lnors_spacearr->lspacearr[i]->vec_ref);
1273                                 printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n", r_lnors_spacearr->lspacearr[i]->ref_alpha,
1274                                        r_lnors_spacearr->lspacearr[i]->ref_beta, r_lnors_spacearr->lspacearr[i]->loops);
1275                                 printf("\t\t(shared with loops");
1276                                 while (loops) {
1277                                         printf(" %d", GET_INT_FROM_POINTER(loops->link));
1278                                         loops = loops->next;
1279                                 }
1280                                 printf(")\n");
1281                         }
1282                         else {
1283                                 printf("Loop %d has no lnor space\n", i);
1284                         }
1285                 }
1286         }
1287 #endif
1288 }
1289
1290
1291 void CDDM_calc_normals_tessface(DerivedMesh *dm)
1292 {
1293         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1294         float (*face_nors)[3];
1295
1296         if (dm->numVertData == 0) return;
1297
1298         /* we don't want to overwrite any referenced layers */
1299         cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1300
1301         /* fill in if it exists */
1302         face_nors = CustomData_get_layer(&dm->faceData, CD_NORMAL);
1303         if (!face_nors) {
1304                 face_nors = CustomData_add_layer(&dm->faceData, CD_NORMAL, CD_CALLOC, NULL, dm->numTessFaceData);
1305         }
1306
1307         BKE_mesh_calc_normals_tessface(cddm->mvert, dm->numVertData,
1308                                        cddm->mface, dm->numTessFaceData, face_nors);
1309
1310         cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1311 }
1312
1313 #if 1
1314 /* TODO(sybren): Delete everything in this #if block after we have ported the modifiers
1315  * to use Mesh instead of DerivedMesh. The code has been copied to mesh_merge.c and ported. */
1316 /**
1317  * Poly compare with vtargetmap
1318  * Function used by #CDDM_merge_verts.
1319  * The function compares poly_source after applying vtargetmap, with poly_target.
1320  * The two polys are identical if they share the same vertices in the same order, or in reverse order,
1321  * but starting position loopstart may be different.
1322  * The function is called with direct_reverse=1 for same order (i.e. same normal),
1323  * and may be called again with direct_reverse=-1 for reverse order.
1324  * \return 1 if polys are identical,  0 if polys are different.
1325  */
1326 static int cddm_poly_compare(
1327         MLoop *mloop_array,
1328         MPoly *mpoly_source, MPoly *mpoly_target,
1329         const int *vtargetmap, const int direct_reverse)
1330 {
1331         int vert_source, first_vert_source, vert_target;
1332         int i_loop_source;
1333         int i_loop_target, i_loop_target_start, i_loop_target_offset, i_loop_target_adjusted;
1334         bool compare_completed = false;
1335         bool same_loops = false;
1336
1337         MLoop *mloop_source, *mloop_target;
1338
1339         BLI_assert(direct_reverse == 1 || direct_reverse == -1);
1340
1341         i_loop_source = 0;
1342         mloop_source = mloop_array + mpoly_source->loopstart;
1343         vert_source = mloop_source->v;
1344
1345         if (vtargetmap[vert_source] != -1) {
1346                 vert_source = vtargetmap[vert_source];
1347         }
1348         else {
1349                 /* All source loop vertices should be mapped */
1350                 BLI_assert(false);
1351         }
1352
1353         /* Find same vertex within mpoly_target's loops */
1354         mloop_target = mloop_array + mpoly_target->loopstart;
1355         for (i_loop_target = 0; i_loop_target < mpoly_target->totloop; i_loop_target++, mloop_target++) {
1356                 if (mloop_target->v == vert_source) {
1357                         break;
1358                 }
1359         }
1360
1361         /* If same vertex not found, then polys cannot be equal */
1362         if (i_loop_target >= mpoly_target->totloop) {
1363                 return false;
1364         }
1365
1366         /* Now mloop_source and m_loop_target have one identical vertex */
1367         /* mloop_source is at position 0, while m_loop_target has advanced to find identical vertex */
1368         /* Go around the loop and check that all vertices match in same order */
1369         /* Skipping source loops when consecutive source vertices are mapped to same target vertex */
1370
1371         i_loop_target_start = i_loop_target;
1372         i_loop_target_offset = 0;
1373         first_vert_source = vert_source;
1374
1375         compare_completed = false;
1376         same_loops = false;
1377
1378         while (!compare_completed) {
1379
1380                 vert_target = mloop_target->v;
1381
1382                 /* First advance i_loop_source, until it points to different vertex, after mapping applied */
1383                 do {
1384                         i_loop_source++;
1385
1386                         if (i_loop_source == mpoly_source->totloop) {
1387                                 /* End of loops for source, must match end of loop for target.  */
1388                                 if (i_loop_target_offset == mpoly_target->totloop - 1) {
1389                                         compare_completed = true;
1390                                         same_loops = true;
1391                                         break;  /* Polys are identical */
1392                                 }
1393                                 else {
1394                                         compare_completed = true;
1395                                         same_loops = false;
1396                                         break;  /* Polys are different */
1397                                 }
1398                         }
1399
1400                         mloop_source++;
1401                         vert_source = mloop_source->v;
1402
1403                         if (vtargetmap[vert_source] != -1) {
1404                                 vert_source = vtargetmap[vert_source];
1405                         }
1406                         else {
1407                                 /* All source loop vertices should be mapped */
1408                                 BLI_assert(false);
1409                         }
1410
1411                 } while (vert_source == vert_target);
1412
1413                 if (compare_completed) {
1414                         break;
1415                 }
1416
1417                 /* Now advance i_loop_target as well */
1418                 i_loop_target_offset++;
1419
1420                 if (i_loop_target_offset == mpoly_target->totloop) {
1421                         /* End of loops for target only, that means no match */
1422                         /* except if all remaining source vertices are mapped to first target */
1423                         for (; i_loop_source < mpoly_source->totloop; i_loop_source++, mloop_source++) {
1424                                 vert_source = vtargetmap[mloop_source->v];
1425                                 if (vert_source != first_vert_source) {
1426                                         compare_completed = true;
1427                                         same_loops = false;
1428                                         break;
1429                                 }
1430                         }
1431                         if (!compare_completed) {
1432                                 same_loops = true;
1433                         }
1434                         break;
1435                 }
1436
1437                 /* Adjust i_loop_target for cycling around and for direct/reverse order defined by delta = +1 or -1 */
1438                 i_loop_target_adjusted = (i_loop_target_start + direct_reverse * i_loop_target_offset) % mpoly_target->totloop;
1439                 if (i_loop_target_adjusted < 0) {
1440                         i_loop_target_adjusted += mpoly_target->totloop;
1441                 }
1442                 mloop_target = mloop_array + mpoly_target->loopstart + i_loop_target_adjusted;
1443                 vert_target = mloop_target->v;
1444
1445                 if (vert_target != vert_source) {
1446                         same_loops = false;  /* Polys are different */
1447                         break;
1448                 }
1449         }
1450         return same_loops;
1451 }
1452
1453 /* Utility stuff for using GHash with polys */
1454
1455 typedef struct PolyKey {
1456         int poly_index;   /* index of the MPoly within the derived mesh */
1457         int totloops;     /* number of loops in the poly */
1458         unsigned int hash_sum;  /* Sum of all vertices indices */
1459         unsigned int hash_xor;  /* Xor of all vertices indices */
1460 } PolyKey;
1461
1462
1463 static unsigned int poly_gset_hash_fn(const void *key)
1464 {
1465         const PolyKey *pk = key;
1466         return pk->hash_sum;
1467 }
1468
1469 static bool poly_gset_compare_fn(const void *k1, const void *k2)
1470 {
1471         const PolyKey *pk1 = k1;
1472         const PolyKey *pk2 = k2;
1473         if ((pk1->hash_sum == pk2->hash_sum) &&
1474             (pk1->hash_xor == pk2->hash_xor) &&
1475             (pk1->totloops == pk2->totloops))
1476         {
1477                 /* Equality - note that this does not mean equality of polys */
1478                 return false;
1479         }
1480         else {
1481                 return true;
1482         }
1483 }
1484
1485 /**
1486  * Merge Verts
1487  *
1488  * This frees dm, and returns a new one.
1489  *
1490  * \param vtargetmap  The table that maps vertices to target vertices.  a value of -1
1491  * indicates a vertex is a target, and is to be kept.
1492  * This array is aligned with 'dm->numVertData'
1493  * \warning \a vtargetmap must **not** contain any chained mapping (v1 -> v2 -> v3 etc.), this is not supported
1494  * and will likely generate corrupted geometry.
1495  *
1496  * \param tot_vtargetmap  The number of non '-1' values in vtargetmap. (not the size)
1497  *
1498  * \param merge_mode enum with two modes.
1499  * - #CDDM_MERGE_VERTS_DUMP_IF_MAPPED
1500  * When called by the Mirror Modifier,
1501  * In this mode it skips any faces that have all vertices merged (to avoid creating pairs
1502  * of faces sharing the same set of vertices)
1503  * - #CDDM_MERGE_VERTS_DUMP_IF_EQUAL
1504  * When called by the Array Modifier,
1505  * In this mode, faces where all vertices are merged are double-checked,
1506  * to see whether all target vertices actually make up a poly already.
1507  * Indeed it could be that all of a poly's vertices are merged,
1508  * but merged to vertices that do not make up a single poly,
1509  * in which case the original poly should not be dumped.
1510  * Actually this later behavior could apply to the Mirror Modifier as well, but the additional checks are
1511  * costly and not necessary in the case of mirror, because each vertex is only merged to its own mirror.
1512  *
1513  * \note #CDDM_recalc_tessellation has to run on the returned DM if you want to access tessfaces.
1514  */
1515 DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap, const int tot_vtargetmap, const int merge_mode)
1516 {
1517 // This was commented out back in 2013, see commit f45d8827bafe6b9eaf9de42f4054e9d84a21955d.
1518 // #define USE_LOOPS
1519         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1520         CDDerivedMesh *cddm2 = NULL;
1521
1522         const int totvert = dm->numVertData;
1523         const int totedge = dm->numEdgeData;
1524         const int totloop = dm->numLoopData;
1525         const int totpoly = dm->numPolyData;
1526
1527         const int totvert_final = totvert - tot_vtargetmap;
1528
1529         MVert *mv, *mvert = MEM_malloc_arrayN(totvert_final, sizeof(*mvert), __func__);
1530         int *oldv         = MEM_malloc_arrayN(totvert_final, sizeof(*oldv), __func__);
1531         int *newv         = MEM_malloc_arrayN(totvert, sizeof(*newv), __func__);
1532         STACK_DECLARE(mvert);
1533         STACK_DECLARE(oldv);
1534
1535         /* Note: create (totedge + totloop) elements because partially invalid polys due to merge may require
1536          * generating new edges, and while in 99% cases we'll still end with less final edges than totedge,
1537          * cases can be forged that would end requiring more... */
1538         MEdge *med, *medge = MEM_malloc_arrayN((totedge + totloop), sizeof(*medge), __func__);
1539         int *olde          = MEM_malloc_arrayN((totedge + totloop), sizeof(*olde), __func__);
1540         int *newe          = MEM_malloc_arrayN((totedge + totloop), sizeof(*newe), __func__);
1541         STACK_DECLARE(medge);
1542         STACK_DECLARE(olde);
1543
1544         MLoop *ml, *mloop = MEM_malloc_arrayN(totloop, sizeof(*mloop), __func__);
1545         int *oldl         = MEM_malloc_arrayN(totloop, sizeof(*oldl), __func__);
1546 #ifdef USE_LOOPS
1547         int *newl         = MEM_malloc_arrayN(totloop, sizeof(*newl), __func__);
1548 #endif
1549         STACK_DECLARE(mloop);
1550         STACK_DECLARE(oldl);
1551
1552         MPoly *mp, *mpoly = MEM_malloc_arrayN(totpoly, sizeof(*medge), __func__);
1553         int *oldp         = MEM_malloc_arrayN(totpoly, sizeof(*oldp), __func__);
1554         STACK_DECLARE(mpoly);
1555         STACK_DECLARE(oldp);
1556
1557         EdgeHash *ehash = BLI_edgehash_new_ex(__func__, totedge);
1558
1559         int i, j, c;
1560
1561         PolyKey *poly_keys;
1562         GSet *poly_gset = NULL;
1563
1564         STACK_INIT(oldv, totvert_final);
1565         STACK_INIT(olde, totedge);
1566         STACK_INIT(oldl, totloop);
1567         STACK_INIT(oldp, totpoly);
1568
1569         STACK_INIT(mvert, totvert_final);
1570         STACK_INIT(medge, totedge);
1571         STACK_INIT(mloop, totloop);
1572         STACK_INIT(mpoly, totpoly);
1573
1574         /* fill newv with destination vertex indices */
1575         mv = cddm->mvert;
1576         c = 0;
1577         for (i = 0; i < totvert; i++, mv++) {
1578                 if (vtargetmap[i] == -1) {
1579                         STACK_PUSH(oldv, i);
1580                         STACK_PUSH(mvert, *mv);
1581                         newv[i] = c++;
1582                 }
1583                 else {
1584                         /* dummy value */
1585                         newv[i] = 0;
1586                 }
1587         }
1588         
1589         /* now link target vertices to destination indices */
1590         for (i = 0; i < totvert; i++) {
1591                 if (vtargetmap[i] != -1) {
1592                         newv[i] = newv[vtargetmap[i]];
1593                 }
1594         }
1595
1596         /* Don't remap vertices in cddm->mloop, because we need to know the original
1597          * indices in order to skip faces with all vertices merged.
1598          * The "update loop indices..." section further down remaps vertices in mloop.
1599          */
1600
1601         /* now go through and fix edges and faces */
1602         med = cddm->medge;
1603         c = 0;
1604         for (i = 0; i < totedge; i++, med++) {
1605                 const unsigned int v1 = (vtargetmap[med->v1] != -1) ? vtargetmap[med->v1] : med->v1;
1606                 const unsigned int v2 = (vtargetmap[med->v2] != -1) ? vtargetmap[med->v2] : med->v2;
1607                 if (LIKELY(v1 != v2)) {
1608                         void **val_p;
1609
1610                         if (BLI_edgehash_ensure_p(ehash, v1, v2, &val_p)) {
1611                                 newe[i] = GET_INT_FROM_POINTER(*val_p);
1612                         }
1613                         else {
1614                                 STACK_PUSH(olde, i);
1615                                 STACK_PUSH(medge, *med);
1616                                 newe[i] = c;
1617                                 *val_p = SET_INT_IN_POINTER(c);
1618                                 c++;
1619                         }
1620                 }
1621                 else {
1622                         newe[i] = -1;
1623                 }
1624         }
1625         
1626         if (merge_mode == CDDM_MERGE_VERTS_DUMP_IF_EQUAL) {
1627                 /* In this mode, we need to determine,  whenever a poly' vertices are all mapped */
1628                 /* if the targets already make up a poly, in which case the new poly is dropped */
1629                 /* This poly equality check is rather complex.   We use a BLI_ghash to speed it up with a first level check */
1630                 PolyKey *mpgh;
1631                 poly_keys = MEM_malloc_arrayN(totpoly, sizeof(PolyKey), __func__);
1632                 poly_gset = BLI_gset_new_ex(poly_gset_hash_fn, poly_gset_compare_fn, __func__, totpoly);
1633                 /* Duplicates allowed because our compare function is not pure equality */
1634                 BLI_gset_flag_set(poly_gset, GHASH_FLAG_ALLOW_DUPES);
1635
1636                 mp = cddm->mpoly;
1637                 mpgh = poly_keys;
1638                 for (i = 0; i < totpoly; i++, mp++, mpgh++) {
1639                         mpgh->poly_index = i;
1640                         mpgh->totloops = mp->totloop;
1641                         ml = cddm->mloop + mp->loopstart;
1642                         mpgh->hash_sum = mpgh->hash_xor = 0;
1643                         for (j = 0; j < mp->totloop; j++, ml++) {
1644                                 mpgh->hash_sum += ml->v;
1645                                 mpgh->hash_xor ^= ml->v;
1646                         }
1647                         BLI_gset_insert(poly_gset, mpgh);
1648                 }
1649
1650                 if (cddm->pmap) {
1651                         MEM_freeN(cddm->pmap);
1652                         MEM_freeN(cddm->pmap_mem);
1653                 }
1654                 /* Can we optimise by reusing an old pmap ?  How do we know an old pmap is stale ?  */
1655                 /* When called by MOD_array.c, the cddm has just been created, so it has no valid pmap.   */
1656                 BKE_mesh_vert_poly_map_create(&cddm->pmap, &cddm->pmap_mem,
1657                                               cddm->mpoly, cddm->mloop,
1658                                               totvert, totpoly, totloop);
1659         }  /* done preparing for fast poly compare */
1660
1661
1662         mp = cddm->mpoly;
1663         mv = cddm->mvert;
1664         for (i = 0; i < totpoly; i++, mp++) {
1665                 MPoly *mp_new;
1666                 
1667                 ml = cddm->mloop + mp->loopstart;
1668
1669                 /* check faces with all vertices merged */
1670                 bool all_vertices_merged = true;
1671
1672                 for (j = 0; j < mp->totloop; j++, ml++) {
1673                         if (vtargetmap[ml->v] == -1) {
1674                                 all_vertices_merged = false;
1675                                 /* This will be used to check for poly using several time the same vert. */
1676                                 mv[ml->v].flag &= ~ME_VERT_TMP_TAG;
1677                         }
1678                         else {
1679                                 /* This will be used to check for poly using several time the same vert. */
1680                                 mv[vtargetmap[ml->v]].flag &= ~ME_VERT_TMP_TAG;
1681                         }
1682                 }
1683
1684                 if (UNLIKELY(all_vertices_merged)) {
1685                         if (merge_mode == CDDM_MERGE_VERTS_DUMP_IF_MAPPED) {
1686                                 /* In this mode, all vertices merged is enough to dump face */
1687                                 continue;
1688                         }
1689                         else if (merge_mode == CDDM_MERGE_VERTS_DUMP_IF_EQUAL) {
1690                                 /* Additional condition for face dump:  target vertices must make up an identical face */
1691                                 /* The test has 2 steps:  (1) first step is fast ghash lookup, but not failproof       */
1692                                 /*                        (2) second step is thorough but more costly poly compare     */
1693                                 int i_poly, v_target;
1694                                 bool found = false;
1695                                 PolyKey pkey;
1696
1697                                 /* Use poly_gset for fast (although not 100% certain) identification of same poly */
1698                                 /* First, make up a poly_summary structure */
1699                                 ml = cddm->mloop + mp->loopstart;
1700                                 pkey.hash_sum = pkey.hash_xor = 0;
1701                                 pkey.totloops = 0;
1702                                 for (j = 0; j < mp->totloop; j++, ml++) {
1703                                         v_target = vtargetmap[ml->v];   /* Cannot be -1, they are all mapped */
1704                                         pkey.hash_sum += v_target;
1705                                         pkey.hash_xor ^= v_target;
1706                                         pkey.totloops++;
1707                                 }
1708                                 if (BLI_gset_haskey(poly_gset, &pkey)) {
1709
1710                                         /* There might be a poly that matches this one.
1711                                          * We could just leave it there and say there is, and do a "continue".
1712                                          * ... but we are checking whether there is an exact poly match.
1713                                          * It's not so costly in terms of CPU since it's very rare, just a lot of complex code.
1714                                          */
1715
1716                                         /* Consider current loop again */
1717                                         ml = cddm->mloop + mp->loopstart;
1718                                         /* Consider the target of the loop's first vert */
1719                                         v_target = vtargetmap[ml->v];
1720                                         /* Now see if v_target belongs to a poly that shares all vertices with source poly,
1721                                          * in same order, or reverse order */
1722
1723                                         for (i_poly = 0; i_poly < cddm->pmap[v_target].count; i_poly++) {
1724                                                 MPoly *target_poly = cddm->mpoly + *(cddm->pmap[v_target].indices + i_poly);
1725
1726                                                 if (cddm_poly_compare(cddm->mloop, mp, target_poly, vtargetmap, +1) ||
1727                                                     cddm_poly_compare(cddm->mloop, mp, target_poly, vtargetmap, -1))
1728                                                 {
1729                                                         found = true;
1730                                                         break;
1731                                                 }
1732                                         }
1733                                         if (found) {
1734                                                 /* Current poly's vertices are mapped to a poly that is strictly identical */
1735                                                 /* Current poly is dumped */
1736                                                 continue;
1737                                         }
1738                                 }
1739                         }
1740                 }
1741
1742
1743                 /* Here either the poly's vertices were not all merged
1744                  * or they were all merged, but targets do not make up an identical poly,
1745                  * the poly is retained.
1746                  */
1747                 ml = cddm->mloop + mp->loopstart;
1748
1749                 c = 0;
1750                 MLoop *last_valid_ml = NULL;
1751                 MLoop *first_valid_ml = NULL;
1752                 bool need_edge_from_last_valid_ml = false;
1753                 bool need_edge_to_first_valid_ml = false;
1754                 int created_edges = 0;
1755                 for (j = 0; j < mp->totloop; j++, ml++) {
1756                         const uint mlv = (vtargetmap[ml->v] != -1) ? vtargetmap[ml->v] : ml->v;
1757 #ifndef NDEBUG
1758                         {
1759                                 MLoop *next_ml = cddm->mloop + mp->loopstart + ((j + 1) % mp->totloop);
1760                                 uint next_mlv = (vtargetmap[next_ml->v] != -1) ? vtargetmap[next_ml->v] : next_ml->v;
1761                                 med = cddm->medge + ml->e;
1762                                 uint v1 = (vtargetmap[med->v1] != -1) ? vtargetmap[med->v1] : med->v1;
1763                                 uint v2 = (vtargetmap[med->v2] != -1) ? vtargetmap[med->v2] : med->v2;
1764                                 BLI_assert((mlv == v1 && next_mlv == v2) || (mlv == v2 && next_mlv == v1));
1765                         }
1766 #endif
1767                         /* A loop is only valid if its matching edge is, and it's not reusing a vertex already used by this poly. */
1768                         if (LIKELY((newe[ml->e] != -1) && ((mv[mlv].flag & ME_VERT_TMP_TAG) == 0))) {
1769                                 mv[mlv].flag |= ME_VERT_TMP_TAG;
1770
1771                                 if (UNLIKELY(last_valid_ml != NULL && need_edge_from_last_valid_ml)) {
1772                                         /* We need to create a new edge between last valid loop and this one! */
1773                                         void **val_p;
1774
1775                                         uint v1 = (vtargetmap[last_valid_ml->v] != -1) ? vtargetmap[last_valid_ml->v] : last_valid_ml->v;
1776                                         uint v2 = mlv;
1777                                         BLI_assert(v1 != v2);
1778                                         if (BLI_edgehash_ensure_p(ehash, v1, v2, &val_p)) {
1779                                                 last_valid_ml->e = GET_INT_FROM_POINTER(*val_p);
1780                                         }
1781                                         else {
1782                                                 const int new_eidx = STACK_SIZE(medge);
1783                                                 STACK_PUSH(olde, olde[last_valid_ml->e]);
1784                                                 STACK_PUSH(medge, cddm->medge[last_valid_ml->e]);
1785                                                 medge[new_eidx].v1 = last_valid_ml->v;
1786                                                 medge[new_eidx].v2 = ml->v;
1787                                                 /* DO NOT change newe mapping, could break actual values due to some deleted original edges. */
1788                                                 *val_p = SET_INT_IN_POINTER(new_eidx);
1789                                                 created_edges++;
1790
1791                                                 last_valid_ml->e = new_eidx;
1792                                         }
1793                                         need_edge_from_last_valid_ml = false;
1794                                 }
1795
1796 #ifdef USE_LOOPS
1797                                 newl[j + mp->loopstart] = STACK_SIZE(mloop);
1798 #endif
1799                                 STACK_PUSH(oldl, j + mp->loopstart);
1800                                 last_valid_ml = STACK_PUSH_RET_PTR(mloop);
1801                                 *last_valid_ml = *ml;
1802                                 if (first_valid_ml == NULL) {
1803                                         first_valid_ml = last_valid_ml;
1804                                 }
1805                                 c++;
1806
1807                                 /* We absolutely HAVE to handle edge index remapping here, otherwise potential newly created edges
1808                                  * in that part of code make remapping later totally unreliable. */
1809                                 BLI_assert(newe[ml->e] != -1);
1810                                 last_valid_ml->e = newe[ml->e];
1811                         }
1812                         else {
1813                                 if (last_valid_ml != NULL) {
1814                                         need_edge_from_last_valid_ml = true;
1815                                 }
1816                                 else {
1817                                         need_edge_to_first_valid_ml = true;
1818                                 }
1819                         }
1820                 }
1821                 if (UNLIKELY(last_valid_ml != NULL && !ELEM(first_valid_ml, NULL, last_valid_ml) &&
1822                              (need_edge_to_first_valid_ml || need_edge_from_last_valid_ml)))
1823                 {
1824                         /* We need to create a new edge between last valid loop and first valid one! */
1825                         void **val_p;
1826
1827                         uint v1 = (vtargetmap[last_valid_ml->v] != -1) ? vtargetmap[last_valid_ml->v] : last_valid_ml->v;
1828                         uint v2 = (vtargetmap[first_valid_ml->v] != -1) ? vtargetmap[first_valid_ml->v] : first_valid_ml->v;
1829                         BLI_assert(v1 != v2);
1830                         if (BLI_edgehash_ensure_p(ehash, v1, v2, &val_p)) {
1831                                 last_valid_ml->e = GET_INT_FROM_POINTER(*val_p);
1832                         }
1833                         else {
1834                                 const int new_eidx = STACK_SIZE(medge);
1835                                 STACK_PUSH(olde, olde[last_valid_ml->e]);
1836                                 STACK_PUSH(medge, cddm->medge[last_valid_ml->e]);
1837                                 medge[new_eidx].v1 = last_valid_ml->v;
1838                                 medge[new_eidx].v2 = first_valid_ml->v;
1839                                 /* DO NOT change newe mapping, could break actual values due to some deleted original edges. */
1840                                 *val_p = SET_INT_IN_POINTER(new_eidx);
1841                                 created_edges++;
1842
1843                                 last_valid_ml->e = new_eidx;
1844                         }
1845                         need_edge_to_first_valid_ml = need_edge_from_last_valid_ml = false;
1846                 }
1847
1848                 if (UNLIKELY(c == 0)) {
1849                         BLI_assert(created_edges == 0);
1850                         continue;
1851                 }
1852                 else if (UNLIKELY(c < 3)) {
1853                         STACK_DISCARD(oldl, c);
1854                         STACK_DISCARD(mloop, c);
1855                         if (created_edges > 0) {
1856                                 for (j = STACK_SIZE(medge) - created_edges; j < STACK_SIZE(medge); j++) {
1857                                         BLI_edgehash_remove(ehash, medge[j].v1, medge[j].v2, NULL);
1858                                 }
1859                                 STACK_DISCARD(olde, created_edges);
1860                                 STACK_DISCARD(medge, created_edges);
1861                         }
1862                         continue;
1863                 }
1864
1865                 mp_new = STACK_PUSH_RET_PTR(mpoly);
1866                 *mp_new = *mp;
1867                 mp_new->totloop = c;
1868                 BLI_assert(mp_new->totloop >= 3);
1869                 mp_new->loopstart = STACK_SIZE(mloop) - c;
1870                 
1871                 STACK_PUSH(oldp, i);
1872         }  /* end of the loop that tests polys   */
1873
1874
1875         if (poly_gset) {
1876                 // printf("hash quality %.6f\n", BLI_gset_calc_quality(poly_gset));
1877
1878                 BLI_gset_free(poly_gset, NULL);
1879                 MEM_freeN(poly_keys);
1880         }
1881         
1882         /*create new cddm*/
1883         cddm2 = (CDDerivedMesh *)CDDM_from_template(
1884                 (DerivedMesh *)cddm, STACK_SIZE(mvert), STACK_SIZE(medge), 0, STACK_SIZE(mloop), STACK_SIZE(mpoly));
1885         
1886         /*update edge indices and copy customdata*/
1887         med = medge;
1888         for (i = 0; i < cddm2->dm.numEdgeData; i++, med++) {
1889                 BLI_assert(newv[med->v1] != -1);
1890                 med->v1 = newv[med->v1];
1891                 BLI_assert(newv[med->v2] != -1);
1892                 med->v2 = newv[med->v2];
1893
1894                 /* Can happen in case vtargetmap contains some double chains, we do not support that. */
1895                 BLI_assert(med->v1 != med->v2);
1896
1897                 CustomData_copy_data(&dm->edgeData, &cddm2->dm.edgeData, olde[i], i, 1);
1898         }
1899         
1900         /*update loop indices and copy customdata*/
1901         ml = mloop;
1902         for (i = 0; i < cddm2->dm.numLoopData; i++, ml++) {
1903                 /* Edge remapping has already be done in main loop handling part above. */
1904                 BLI_assert(newv[ml->v] != -1);
1905                 ml->v = newv[ml->v];
1906
1907                 CustomData_copy_data(&dm->loopData, &cddm2->dm.loopData, oldl[i], i, 1);
1908         }
1909         
1910         /*copy vertex customdata*/
1911         mv = mvert;
1912         for (i = 0; i < cddm2->dm.numVertData; i++, mv++) {
1913                 CustomData_copy_data(&dm->vertData, &cddm2->dm.vertData, oldv[i], i, 1);
1914         }
1915         
1916         /*copy poly customdata*/
1917         mp = mpoly;
1918         for (i = 0; i < cddm2->dm.numPolyData; i++, mp++) {
1919                 CustomData_copy_data(&dm->polyData, &cddm2->dm.polyData, oldp[i], i, 1);
1920         }
1921         
1922         /*copy over data.  CustomData_add_layer can do this, need to look it up.*/
1923         memcpy(cddm2->mvert, mvert, sizeof(MVert) * STACK_SIZE(mvert));
1924         memcpy(cddm2->medge, medge, sizeof(MEdge) * STACK_SIZE(medge));
1925         memcpy(cddm2->mloop, mloop, sizeof(MLoop) * STACK_SIZE(mloop));
1926         memcpy(cddm2->mpoly, mpoly, sizeof(MPoly) * STACK_SIZE(mpoly));
1927
1928         MEM_freeN(mvert);
1929         MEM_freeN(medge);
1930         MEM_freeN(mloop);
1931         MEM_freeN(mpoly);
1932
1933         MEM_freeN(newv);
1934         MEM_freeN(newe);
1935 #ifdef USE_LOOPS
1936         MEM_freeN(newl);
1937 #endif
1938
1939         MEM_freeN(oldv);
1940         MEM_freeN(olde);
1941         MEM_freeN(oldl);
1942         MEM_freeN(oldp);
1943
1944         BLI_edgehash_free(ehash, NULL);
1945
1946         /*free old derivedmesh*/
1947         dm->needsFree = 1;
1948         dm->release(dm);
1949         
1950         return (DerivedMesh *)cddm2;
1951 }
1952 #endif
1953
1954 void CDDM_calc_edges_tessface(DerivedMesh *dm)
1955 {
1956         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1957         CustomData edgeData;
1958         EdgeSetIterator *ehi;
1959         MFace *mf = cddm->mface;
1960         MEdge *med;
1961         EdgeSet *eh;
1962         int i, *index, numEdges, numFaces = dm->numTessFaceData;
1963
1964         eh = BLI_edgeset_new_ex(__func__, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(numFaces));
1965
1966         for (i = 0; i < numFaces; i++, mf++) {
1967                 BLI_edgeset_add(eh, mf->v1, mf->v2);
1968                 BLI_edgeset_add(eh, mf->v2, mf->v3);
1969                 
1970                 if (mf->v4) {
1971                         BLI_edgeset_add(eh, mf->v3, mf->v4);
1972                         BLI_edgeset_add(eh, mf->v4, mf->v1);
1973                 }
1974                 else {
1975                         BLI_edgeset_add(eh, mf->v3, mf->v1);
1976                 }
1977         }
1978
1979         numEdges = BLI_edgeset_len(eh);
1980
1981         /* write new edges into a temporary CustomData */
1982         CustomData_reset(&edgeData);
1983         CustomData_add_layer(&edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
1984         CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
1985
1986         med = CustomData_get_layer(&edgeData, CD_MEDGE);
1987         index = CustomData_get_layer(&edgeData, CD_ORIGINDEX);
1988
1989         for (ehi = BLI_edgesetIterator_new(eh), i = 0;
1990              BLI_edgesetIterator_isDone(ehi) == false;
1991              BLI_edgesetIterator_step(ehi), i++, med++, index++)
1992         {
1993                 BLI_edgesetIterator_getKey(ehi, &med->v1, &med->v2);
1994
1995                 med->flag = ME_EDGEDRAW | ME_EDGERENDER;
1996                 *index = ORIGINDEX_NONE;
1997         }
1998         BLI_edgesetIterator_free(ehi);
1999
2000         /* free old CustomData and assign new one */
2001         CustomData_free(&dm->edgeData, dm->numEdgeData);
2002         dm->edgeData = edgeData;
2003         dm->numEdgeData = numEdges;
2004
2005         cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
2006
2007         BLI_edgeset_free(eh);
2008 }
2009
2010 /* warning, this uses existing edges but CDDM_calc_edges_tessface() doesn't */
2011 void CDDM_calc_edges(DerivedMesh *dm)
2012 {
2013         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2014         CustomData edgeData;
2015         EdgeHashIterator *ehi;
2016         MPoly *mp = cddm->mpoly;
2017         MLoop *ml;
2018         MEdge *med, *origmed;
2019         EdgeHash *eh;
2020         unsigned int eh_reserve;
2021         int v1, v2;
2022         const int *eindex;
2023         int i, j, *index;
2024         const int numFaces = dm->numPolyData;
2025         const int numLoops = dm->numLoopData;
2026         int numEdges = dm->numEdgeData;
2027
2028         eindex = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
2029         med = cddm->medge;
2030
2031         eh_reserve = max_ii(med ? numEdges : 0, BLI_EDGEHASH_SIZE_GUESS_FROM_LOOPS(numLoops));
2032         eh = BLI_edgehash_new_ex(__func__, eh_reserve);
2033         if (med) {
2034                 for (i = 0; i < numEdges; i++, med++) {
2035                         BLI_edgehash_insert(eh, med->v1, med->v2, SET_INT_IN_POINTER(i + 1));
2036                 }
2037         }
2038
2039         for (i = 0; i < numFaces; i++, mp++) {
2040                 ml = cddm->mloop + mp->loopstart;
2041                 for (j = 0; j < mp->totloop; j++, ml++) {
2042                         v1 = ml->v;
2043                         v2 = ME_POLY_LOOP_NEXT(cddm->mloop, mp, j)->v;
2044                         BLI_edgehash_reinsert(eh, v1, v2, NULL);
2045                 }
2046         }
2047
2048         numEdges = BLI_edgehash_len(eh);
2049
2050         /* write new edges into a temporary CustomData */
2051         CustomData_reset(&edgeData);
2052         CustomData_add_layer(&edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
2053         CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
2054
2055         origmed = cddm->medge;
2056         med = CustomData_get_layer(&edgeData, CD_MEDGE);
2057         index = CustomData_get_layer(&edgeData, CD_ORIGINDEX);
2058
2059         for (ehi = BLI_edgehashIterator_new(eh), i = 0;
2060              BLI_edgehashIterator_isDone(ehi) == false;
2061              BLI_edgehashIterator_step(ehi), ++i, ++med, ++index)
2062         {
2063                 BLI_edgehashIterator_getKey(ehi, &med->v1, &med->v2);
2064                 j = GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
2065
2066                 if (j == 0 || !eindex) {
2067                         med->flag = ME_EDGEDRAW | ME_EDGERENDER;
2068                         *index = ORIGINDEX_NONE;
2069                 }
2070                 else {
2071                         med->flag = ME_EDGEDRAW | ME_EDGERENDER | origmed[j - 1].flag;
2072                         *index = eindex[j - 1];
2073                 }
2074
2075                 BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(i));
2076         }
2077         BLI_edgehashIterator_free(ehi);
2078
2079         /* free old CustomData and assign new one */
2080         CustomData_free(&dm->edgeData, dm->numEdgeData);
2081         dm->edgeData = edgeData;
2082         dm->numEdgeData = numEdges;
2083
2084         cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
2085
2086         mp = cddm->mpoly;
2087         for (i = 0; i < numFaces; i++, mp++) {
2088                 ml = cddm->mloop + mp->loopstart;
2089                 for (j = 0; j < mp->totloop; j++, ml++) {
2090                         v1 = ml->v;
2091                         v2 = ME_POLY_LOOP_NEXT(cddm->mloop, mp, j)->v;
2092                         ml->e = GET_INT_FROM_POINTER(BLI_edgehash_lookup(eh, v1, v2));
2093                 }
2094         }
2095
2096         BLI_edgehash_free(eh, NULL);
2097 }
2098
2099 void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
2100 {
2101         BLI_assert(numVerts >= 0);
2102         if (numVerts < dm->numVertData)
2103                 CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts);
2104
2105         dm->numVertData = numVerts;
2106 }
2107
2108 void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
2109 {
2110         BLI_assert(numEdges >= 0);
2111         if (numEdges < dm->numEdgeData)
2112                 CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges);
2113
2114         dm->numEdgeData = numEdges;
2115 }
2116
2117 void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
2118 {
2119         BLI_assert(numTessFaces >= 0);
2120         if (numTessFaces < dm->numTessFaceData)
2121                 CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces);
2122
2123         dm->numTessFaceData = numTessFaces;
2124 }
2125
2126 void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
2127 {
2128         BLI_assert(numLoops >= 0);
2129         if (numLoops < dm->numLoopData)
2130                 CustomData_free_elem(&dm->loopData, numLoops, dm->numLoopData - numLoops);
2131
2132         dm->numLoopData = numLoops;
2133 }
2134
2135 void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys)
2136 {
2137         BLI_assert(numPolys >= 0);
2138         if (numPolys < dm->numPolyData)
2139                 CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys);
2140
2141         dm->numPolyData = numPolys;
2142 }
2143
2144 /* mesh element access functions */
2145
2146 MVert *CDDM_get_vert(DerivedMesh *dm, int index)
2147 {
2148         return &((CDDerivedMesh *)dm)->mvert[index];
2149 }
2150
2151 MEdge *CDDM_get_edge(DerivedMesh *dm, int index)
2152 {
2153         return &((CDDerivedMesh *)dm)->medge[index];
2154 }
2155
2156 MFace *CDDM_get_tessface(DerivedMesh *dm, int index)
2157 {
2158         return &((CDDerivedMesh *)dm)->mface[index];
2159 }
2160
2161 MLoop *CDDM_get_loop(DerivedMesh *dm, int index)
2162 {
2163         return &((CDDerivedMesh *)dm)->mloop[index];
2164 }
2165
2166 MPoly *CDDM_get_poly(DerivedMesh *dm, int index)
2167 {
2168         return &((CDDerivedMesh *)dm)->mpoly[index];
2169 }
2170
2171 /* array access functions */
2172
2173 MVert *CDDM_get_verts(DerivedMesh *dm)
2174 {
2175         return ((CDDerivedMesh *)dm)->mvert;
2176 }
2177
2178 MEdge *CDDM_get_edges(DerivedMesh *dm)
2179 {
2180         return ((CDDerivedMesh *)dm)->medge;
2181 }
2182
2183 MFace *CDDM_get_tessfaces(DerivedMesh *dm)
2184 {
2185         return ((CDDerivedMesh *)dm)->mface;
2186 }
2187
2188 MLoop *CDDM_get_loops(DerivedMesh *dm)
2189 {
2190         return ((CDDerivedMesh *)dm)->mloop;
2191 }
2192
2193 MPoly *CDDM_get_polys(DerivedMesh *dm)
2194 {
2195         return ((CDDerivedMesh *)dm)->mpoly;
2196 }
2197
2198 void CDDM_tessfaces_to_faces(DerivedMesh *dm)
2199 {
2200         /* converts mfaces to mpolys/mloops */
2201         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2202
2203         BKE_mesh_convert_mfaces_to_mpolys_ex(
2204                 NULL, &cddm->dm.faceData, &cddm->dm.loopData, &cddm->dm.polyData,
2205                 cddm->dm.numEdgeData, cddm->dm.numTessFaceData,
2206                 cddm->dm.numLoopData, cddm->dm.numPolyData,
2207                 cddm->medge, cddm->mface,
2208                 &cddm->dm.numLoopData, &cddm->dm.numPolyData,
2209                 &cddm->mloop, &cddm->mpoly);
2210 }
2211
2212 void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert)
2213 {
2214         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2215         
2216         if (!CustomData_has_layer(&dm->vertData, CD_MVERT))
2217                 CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData);
2218
2219         cddm->mvert = mvert;
2220 }
2221
2222 void CDDM_set_medge(DerivedMesh *dm, MEdge *medge)
2223 {
2224         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2225
2226         if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE))
2227                 CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData);
2228
2229         cddm->medge = medge;
2230 }
2231
2232 void CDDM_set_mface(DerivedMesh *dm, MFace *mface)
2233 {
2234         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2235
2236         if (!CustomData_has_layer(&dm->faceData, CD_MFACE))
2237                 CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData);
2238
2239         cddm->mface = mface;
2240 }
2241
2242 void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop)
2243 {
2244         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2245
2246         if (!CustomData_has_layer(&dm->loopData, CD_MLOOP))
2247                 CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData);
2248
2249         cddm->mloop = mloop;
2250 }
2251
2252 void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly)
2253 {
2254         CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
2255
2256         if (!CustomData_has_layer(&dm->polyData, CD_MPOLY))
2257                 CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData);
2258
2259         cddm->mpoly = mpoly;
2260 }