Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
[blender.git] / source / blender / blenkernel / intern / cdderivedmesh.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software  Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2006 Blender Foundation.
17  * All rights reserved.
18  * Implementation of CDDerivedMesh.
19  *
20  * BKE_cdderivedmesh.h contains the function prototypes for this file.
21  */
22
23 /** \file
24  * \ingroup bke
25  */
26
27 #include "atomic_ops.h"
28
29 #include "BLI_math.h"
30 #include "BLI_utildefines.h"
31
32 #include "BKE_pbvh.h"
33 #include "BKE_cdderivedmesh.h"
34 #include "BKE_mesh.h"
35 #include "BKE_mesh_mapping.h"
36 #include "BKE_object.h"
37 #include "BKE_paint.h"
38 #include "BKE_editmesh.h"
39 #include "BKE_curve.h"
40
41 #include "DNA_mesh_types.h"
42 #include "DNA_meshdata_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_curve_types.h" /* for Curve */
45
46 #include "MEM_guardedalloc.h"
47
48 #include <string.h>
49 #include <limits.h>
50 #include <math.h>
51
52 typedef struct {
53   DerivedMesh dm;
54
55   /* these point to data in the DerivedMesh custom data layers,
56    * they are only here for efficiency and convenience */
57   MVert *mvert;
58   MEdge *medge;
59   MFace *mface;
60   MLoop *mloop;
61   MPoly *mpoly;
62
63   /* Cached */
64   struct PBVH *pbvh;
65   bool pbvh_draw;
66
67   /* Mesh connectivity */
68   MeshElemMap *pmap;
69   int *pmap_mem;
70 } CDDerivedMesh;
71
72 /**************** DerivedMesh interface functions ****************/
73 static int cdDM_getNumVerts(DerivedMesh *dm)
74 {
75   return dm->numVertData;
76 }
77
78 static int cdDM_getNumEdges(DerivedMesh *dm)
79 {
80   return dm->numEdgeData;
81 }
82
83 static int cdDM_getNumTessFaces(DerivedMesh *dm)
84 {
85   /* uncomment and add a breakpoint on the printf()
86    * to help debug tessfaces issues since BMESH merge. */
87 #if 0
88   if (dm->numTessFaceData == 0 && dm->numPolyData != 0) {
89     printf("%s: has no faces!\n");
90   }
91 #endif
92   return dm->numTessFaceData;
93 }
94
95 static int cdDM_getNumLoops(DerivedMesh *dm)
96 {
97   return dm->numLoopData;
98 }
99
100 static int cdDM_getNumPolys(DerivedMesh *dm)
101 {
102   return dm->numPolyData;
103 }
104
105 static void cdDM_getVert(DerivedMesh *dm, int index, MVert *r_vert)
106 {
107   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
108   *r_vert = cddm->mvert[index];
109 }
110
111 static void cdDM_getEdge(DerivedMesh *dm, int index, MEdge *r_edge)
112 {
113   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
114   *r_edge = cddm->medge[index];
115 }
116
117 static void cdDM_getTessFace(DerivedMesh *dm, int index, MFace *r_face)
118 {
119   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
120   *r_face = cddm->mface[index];
121 }
122
123 static void cdDM_copyVertArray(DerivedMesh *dm, MVert *r_vert)
124 {
125   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
126   memcpy(r_vert, cddm->mvert, sizeof(*r_vert) * dm->numVertData);
127 }
128
129 static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *r_edge)
130 {
131   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
132   memcpy(r_edge, cddm->medge, sizeof(*r_edge) * dm->numEdgeData);
133 }
134
135 static void cdDM_copyTessFaceArray(DerivedMesh *dm, MFace *r_face)
136 {
137   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
138   memcpy(r_face, cddm->mface, sizeof(*r_face) * dm->numTessFaceData);
139 }
140
141 static void cdDM_copyLoopArray(DerivedMesh *dm, MLoop *r_loop)
142 {
143   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
144   memcpy(r_loop, cddm->mloop, sizeof(*r_loop) * dm->numLoopData);
145 }
146
147 static void cdDM_copyPolyArray(DerivedMesh *dm, MPoly *r_poly)
148 {
149   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
150   memcpy(r_poly, cddm->mpoly, sizeof(*r_poly) * dm->numPolyData);
151 }
152
153 static void cdDM_getMinMax(DerivedMesh *dm, float r_min[3], float r_max[3])
154 {
155   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
156   int i;
157
158   if (dm->numVertData) {
159     for (i = 0; i < dm->numVertData; i++) {
160       minmax_v3v3_v3(r_min, r_max, cddm->mvert[i].co);
161     }
162   }
163   else {
164     zero_v3(r_min);
165     zero_v3(r_max);
166   }
167 }
168
169 static void cdDM_getVertCo(DerivedMesh *dm, int index, float r_co[3])
170 {
171   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
172
173   copy_v3_v3(r_co, cddm->mvert[index].co);
174 }
175
176 static void cdDM_getVertCos(DerivedMesh *dm, float (*r_cos)[3])
177 {
178   MVert *mv = CDDM_get_verts(dm);
179   int i;
180
181   for (i = 0; i < dm->numVertData; i++, mv++) {
182     copy_v3_v3(r_cos[i], mv->co);
183   }
184 }
185
186 static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
187 {
188   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
189   normal_short_to_float_v3(r_no, cddm->mvert[index].no);
190 }
191
192 static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm)
193 {
194   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
195
196   if (!cddm->pmap && ob->type == OB_MESH) {
197     Mesh *me = ob->data;
198
199     BKE_mesh_vert_poly_map_create(
200         &cddm->pmap, &cddm->pmap_mem, me->mpoly, me->mloop, me->totvert, me->totpoly, me->totloop);
201   }
202
203   return cddm->pmap;
204 }
205
206 static bool check_sculpt_object_deformed(Object *object, bool for_construction)
207 {
208   bool deformed = false;
209
210   /* Active modifiers means extra deformation, which can't be handled correct
211    * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
212    * stuff and show final DerivedMesh so user would see actual object shape.
213    */
214   deformed |= object->sculpt->modifiers_active;
215
216   if (for_construction) {
217     deformed |= object->sculpt->kb != NULL;
218   }
219   else {
220     /* As in case with modifiers, we can't synchronize deformation made against
221      * PBVH and non-locked keyblock, so also use PBVH only for brushes and
222      * final DM to give final result to user.
223      */
224     deformed |= object->sculpt->kb && (object->shapeflag & OB_SHAPE_LOCK) == 0;
225   }
226
227   return deformed;
228 }
229
230 static bool can_pbvh_draw(Object *ob, DerivedMesh *dm)
231 {
232   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
233   Mesh *me = ob->data;
234   bool deformed = check_sculpt_object_deformed(ob, false);
235
236   if (deformed) {
237     return false;
238   }
239
240   return cddm->mvert == me->mvert || ob->sculpt->kb;
241 }
242
243 static PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
244 {
245   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
246
247   if (!ob) {
248     cddm->pbvh = NULL;
249     return NULL;
250   }
251
252   if (!ob->sculpt) {
253     return NULL;
254   }
255
256   if (ob->sculpt->pbvh) {
257     cddm->pbvh = ob->sculpt->pbvh;
258     cddm->pbvh_draw = can_pbvh_draw(ob, dm);
259   }
260
261   /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH */
262   if (!cddm->pbvh && ob->sculpt->bm) {
263     cddm->pbvh = BKE_pbvh_new();
264     cddm->pbvh_draw = true;
265
266     BKE_pbvh_build_bmesh(cddm->pbvh,
267                          ob->sculpt->bm,
268                          ob->sculpt->bm_smooth_shading,
269                          ob->sculpt->bm_log,
270                          ob->sculpt->cd_vert_node_offset,
271                          ob->sculpt->cd_face_node_offset);
272
273     pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
274   }
275
276   /* always build pbvh from original mesh, and only use it for drawing if
277    * this derivedmesh is just original mesh. it's the multires subsurf dm
278    * that this is actually for, to support a pbvh on a modified mesh */
279   if (!cddm->pbvh && ob->type == OB_MESH) {
280     Mesh *me = BKE_object_get_original_mesh(ob);
281     const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
282     MLoopTri *looptri;
283     bool deformed;
284
285     cddm->pbvh = BKE_pbvh_new();
286     cddm->pbvh_draw = can_pbvh_draw(ob, dm);
287
288     looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
289
290     BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
291
292     BKE_pbvh_build_mesh(cddm->pbvh,
293                         me->mpoly,
294                         me->mloop,
295                         me->mvert,
296                         me->totvert,
297                         &me->vdata,
298                         &me->ldata,
299                         looptri,
300                         looptris_num);
301
302     pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
303
304     deformed = check_sculpt_object_deformed(ob, true);
305
306     if (deformed && ob->derivedDeform) {
307       DerivedMesh *deformdm = ob->derivedDeform;
308       float(*vertCos)[3];
309       int totvert;
310
311       totvert = deformdm->getNumVerts(deformdm);
312       vertCos = MEM_malloc_arrayN(totvert, sizeof(float[3]), "cdDM_getPBVH vertCos");
313       deformdm->getVertCos(deformdm, vertCos);
314       BKE_pbvh_apply_vertCos(cddm->pbvh, vertCos, totvert);
315       MEM_freeN(vertCos);
316     }
317   }
318
319   return cddm->pbvh;
320 }
321
322 static void cdDM_foreachMappedVert(DerivedMesh *dm,
323                                    void (*func)(void *userData,
324                                                 int index,
325                                                 const float co[3],
326                                                 const float no_f[3],
327                                                 const short no_s[3]),
328                                    void *userData,
329                                    DMForeachFlag flag)
330 {
331   MVert *mv = CDDM_get_verts(dm);
332   const int *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
333   int i;
334
335   if (index) {
336     for (i = 0; i < dm->numVertData; i++, mv++) {
337       const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
338       const int orig = *index++;
339       if (orig == ORIGINDEX_NONE) {
340         continue;
341       }
342       func(userData, orig, mv->co, NULL, no);
343     }
344   }
345   else {
346     for (i = 0; i < dm->numVertData; i++, mv++) {
347       const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
348       func(userData, i, mv->co, NULL, no);
349     }
350   }
351 }
352
353 static void cdDM_foreachMappedEdge(
354     DerivedMesh *dm,
355     void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
356     void *userData)
357 {
358   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
359   MVert *mv = cddm->mvert;
360   MEdge *med = cddm->medge;
361   int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
362
363   for (i = 0; i < dm->numEdgeData; i++, med++) {
364     if (index) {
365       orig = *index++;
366       if (orig == ORIGINDEX_NONE) {
367         continue;
368       }
369       func(userData, orig, mv[med->v1].co, mv[med->v2].co);
370     }
371     else {
372       func(userData, i, mv[med->v1].co, mv[med->v2].co);
373     }
374   }
375 }
376
377 static void cdDM_foreachMappedLoop(DerivedMesh *dm,
378                                    void (*func)(void *userData,
379                                                 int vertex_index,
380                                                 int face_index,
381                                                 const float co[3],
382                                                 const float no[3]),
383                                    void *userData,
384                                    DMForeachFlag flag)
385 {
386   /* We can't use dm->getLoopDataLayout(dm) here,
387    * we want to always access dm->loopData, EditDerivedBMesh would
388    * return loop data from bmesh itself. */
389   const float(*lnors)[3] = (flag & DM_FOREACH_USE_NORMAL) ? DM_get_loop_data_layer(dm, CD_NORMAL) :
390                                                             NULL;
391
392   const MVert *mv = CDDM_get_verts(dm);
393   const MLoop *ml = CDDM_get_loops(dm);
394   const MPoly *mp = CDDM_get_polys(dm);
395   const int *v_index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
396   const int *f_index = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
397   int p_idx, i;
398
399   for (p_idx = 0; p_idx < dm->numPolyData; ++p_idx, ++mp) {
400     for (i = 0; i < mp->totloop; ++i, ++ml) {
401       const int v_idx = v_index ? v_index[ml->v] : ml->v;
402       const int f_idx = f_index ? f_index[p_idx] : p_idx;
403       const float *no = lnors ? *lnors++ : NULL;
404       if (!ELEM(ORIGINDEX_NONE, v_idx, f_idx)) {
405         func(userData, v_idx, f_idx, mv[ml->v].co, no);
406       }
407     }
408   }
409 }
410
411 static void cdDM_foreachMappedFaceCenter(
412     DerivedMesh *dm,
413     void (*func)(void *userData, int index, const float cent[3], const float no[3]),
414     void *userData,
415     DMForeachFlag flag)
416 {
417   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
418   MVert *mvert = cddm->mvert;
419   MPoly *mp;
420   MLoop *ml;
421   int i, orig, *index;
422
423   index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
424   mp = cddm->mpoly;
425   for (i = 0; i < dm->numPolyData; i++, mp++) {
426     float cent[3];
427     float *no, _no[3];
428
429     if (index) {
430       orig = *index++;
431       if (orig == ORIGINDEX_NONE) {
432         continue;
433       }
434     }
435     else {
436       orig = i;
437     }
438
439     ml = &cddm->mloop[mp->loopstart];
440     BKE_mesh_calc_poly_center(mp, ml, mvert, cent);
441
442     if (flag & DM_FOREACH_USE_NORMAL) {
443       BKE_mesh_calc_poly_normal(mp, ml, mvert, (no = _no));
444     }
445     else {
446       no = NULL;
447     }
448
449     func(userData, orig, cent, no);
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(&dm->faceData,
458                                                      &dm->loopData,
459                                                      &dm->polyData,
460                                                      cddm->mvert,
461                                                      dm->numTessFaceData,
462                                                      dm->numLoopData,
463                                                      dm->numPolyData,
464                                                      do_face_nor_cpy);
465
466   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
467
468   /* Tessellation recreated faceData, and the active layer indices need to get re-propagated
469    * from loops and polys to faces */
470   CustomData_bmesh_update_active_layers(&dm->faceData, &dm->loopData);
471 }
472
473 void CDDM_recalc_tessellation(DerivedMesh *dm)
474 {
475   CDDM_recalc_tessellation_ex(dm, true);
476 }
477
478 void CDDM_recalc_looptri(DerivedMesh *dm)
479 {
480   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
481   const unsigned int totpoly = dm->numPolyData;
482   const unsigned int totloop = dm->numLoopData;
483
484   DM_ensure_looptri_data(dm);
485   BLI_assert(totpoly == 0 || cddm->dm.looptris.array_wip != NULL);
486
487   BKE_mesh_recalc_looptri(
488       cddm->mloop, cddm->mpoly, cddm->mvert, totloop, totpoly, cddm->dm.looptris.array_wip);
489
490   BLI_assert(cddm->dm.looptris.array == NULL);
491   atomic_cas_ptr(
492       (void **)&cddm->dm.looptris.array, cddm->dm.looptris.array, cddm->dm.looptris.array_wip);
493   cddm->dm.looptris.array_wip = NULL;
494 }
495
496 static void cdDM_free_internal(CDDerivedMesh *cddm)
497 {
498   if (cddm->pmap) {
499     MEM_freeN(cddm->pmap);
500   }
501   if (cddm->pmap_mem) {
502     MEM_freeN(cddm->pmap_mem);
503   }
504 }
505
506 static void cdDM_release(DerivedMesh *dm)
507 {
508   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
509
510   if (DM_release(dm)) {
511     cdDM_free_internal(cddm);
512     MEM_freeN(cddm);
513   }
514 }
515
516 /**************** CDDM interface functions ****************/
517 static CDDerivedMesh *cdDM_create(const char *desc)
518 {
519   CDDerivedMesh *cddm;
520   DerivedMesh *dm;
521
522   cddm = MEM_callocN(sizeof(*cddm), desc);
523   dm = &cddm->dm;
524
525   dm->getMinMax = cdDM_getMinMax;
526
527   dm->getNumVerts = cdDM_getNumVerts;
528   dm->getNumEdges = cdDM_getNumEdges;
529   dm->getNumTessFaces = cdDM_getNumTessFaces;
530   dm->getNumLoops = cdDM_getNumLoops;
531   dm->getNumPolys = cdDM_getNumPolys;
532
533   dm->getVert = cdDM_getVert;
534   dm->getEdge = cdDM_getEdge;
535   dm->getTessFace = cdDM_getTessFace;
536
537   dm->copyVertArray = cdDM_copyVertArray;
538   dm->copyEdgeArray = cdDM_copyEdgeArray;
539   dm->copyTessFaceArray = cdDM_copyTessFaceArray;
540   dm->copyLoopArray = cdDM_copyLoopArray;
541   dm->copyPolyArray = cdDM_copyPolyArray;
542
543   dm->getVertData = DM_get_vert_data;
544   dm->getEdgeData = DM_get_edge_data;
545   dm->getTessFaceData = DM_get_tessface_data;
546   dm->getVertDataArray = DM_get_vert_data_layer;
547   dm->getEdgeDataArray = DM_get_edge_data_layer;
548   dm->getTessFaceDataArray = DM_get_tessface_data_layer;
549
550   dm->calcNormals = CDDM_calc_normals;
551   dm->calcLoopNormals = CDDM_calc_loop_normals;
552   dm->calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
553   dm->calcLoopTangents = DM_calc_loop_tangents;
554   dm->recalcTessellation = CDDM_recalc_tessellation;
555   dm->recalcLoopTri = CDDM_recalc_looptri;
556
557   dm->getVertCos = cdDM_getVertCos;
558   dm->getVertCo = cdDM_getVertCo;
559   dm->getVertNo = cdDM_getVertNo;
560
561   dm->getPBVH = cdDM_getPBVH;
562   dm->getPolyMap = cdDM_getPolyMap;
563
564   dm->foreachMappedVert = cdDM_foreachMappedVert;
565   dm->foreachMappedEdge = cdDM_foreachMappedEdge;
566   dm->foreachMappedLoop = cdDM_foreachMappedLoop;
567   dm->foreachMappedFaceCenter = cdDM_foreachMappedFaceCenter;
568
569   dm->release = cdDM_release;
570
571   return cddm;
572 }
573
574 DerivedMesh *CDDM_new(int numVerts, int numEdges, int numTessFaces, int numLoops, int numPolys)
575 {
576   CDDerivedMesh *cddm = cdDM_create("CDDM_new dm");
577   DerivedMesh *dm = &cddm->dm;
578
579   DM_init(dm, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys);
580
581   CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
582   CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
583   CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
584   CustomData_add_layer(&dm->polyData, CD_ORIGINDEX, CD_CALLOC, NULL, numPolys);
585
586   CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
587   CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
588   CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
589   CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
590   CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
591
592   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
593   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
594   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
595   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
596   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
597
598   return dm;
599 }
600
601 DerivedMesh *CDDM_from_mesh(Mesh *mesh)
602 {
603   return CDDM_from_mesh_ex(mesh, CD_REFERENCE, &CD_MASK_MESH);
604 }
605
606 DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh,
607                                eCDAllocType alloctype,
608                                const CustomData_MeshMasks *mask)
609 {
610   CDDerivedMesh *cddm = cdDM_create(__func__);
611   DerivedMesh *dm = &cddm->dm;
612   CustomData_MeshMasks cddata_masks = *mask;
613
614   cddata_masks.lmask &= ~CD_MASK_MDISPS;
615
616   /* this does a referenced copy, with an exception for fluidsim */
617
618   DM_init(dm,
619           DM_TYPE_CDDM,
620           mesh->totvert,
621           mesh->totedge,
622           0 /* mesh->totface */,
623           mesh->totloop,
624           mesh->totpoly);
625
626   /* This should actually be dm->deformedOnly = mesh->runtime.deformed_only,
627    * but only if the original mesh had its deformed_only flag correctly set
628    * (which isn't generally the case). */
629   dm->deformedOnly = 1;
630   dm->cd_flag = mesh->cd_flag;
631
632   if (mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL) {
633     dm->dirty |= DM_DIRTY_NORMALS;
634   }
635   /* TODO DM_DIRTY_TESS_CDLAYERS ? Maybe not though,
636    * since we probably want to switch to looptris? */
637
638   CustomData_merge(&mesh->vdata, &dm->vertData, cddata_masks.vmask, alloctype, mesh->totvert);
639   CustomData_merge(&mesh->edata, &dm->edgeData, cddata_masks.emask, alloctype, mesh->totedge);
640   CustomData_merge(&mesh->fdata,
641                    &dm->faceData,
642                    cddata_masks.fmask | CD_MASK_ORIGINDEX,
643                    alloctype,
644                    0 /* mesh->totface */);
645   CustomData_merge(&mesh->ldata, &dm->loopData, cddata_masks.lmask, alloctype, mesh->totloop);
646   CustomData_merge(&mesh->pdata, &dm->polyData, cddata_masks.pmask, alloctype, mesh->totpoly);
647
648   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
649   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
650   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
651   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
652 #if 0
653   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
654 #else
655   cddm->mface = NULL;
656 #endif
657
658   /* commented since even when CD_ORIGINDEX was first added this line fails
659    * on the default cube, (after editmode toggle too) - campbell */
660 #if 0
661   BLI_assert(CustomData_has_layer(&cddm->dm.faceData, CD_ORIGINDEX));
662 #endif
663
664   return dm;
665 }
666
667 DerivedMesh *CDDM_from_curve(Object *ob)
668 {
669   ListBase disp = {NULL, NULL};
670
671   if (ob->runtime.curve_cache) {
672     disp = ob->runtime.curve_cache->disp;
673   }
674
675   return CDDM_from_curve_displist(ob, &disp);
676 }
677
678 DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
679 {
680   Curve *cu = (Curve *)ob->data;
681   DerivedMesh *dm;
682   CDDerivedMesh *cddm;
683   MVert *allvert;
684   MEdge *alledge;
685   MLoop *allloop;
686   MPoly *allpoly;
687   MLoopUV *alluv = NULL;
688   int totvert, totedge, totloop, totpoly;
689   bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
690
691   if (BKE_mesh_nurbs_displist_to_mdata(ob,
692                                        dispbase,
693                                        &allvert,
694                                        &totvert,
695                                        &alledge,
696                                        &totedge,
697                                        &allloop,
698                                        &allpoly,
699                                        (use_orco_uv) ? &alluv : NULL,
700                                        &totloop,
701                                        &totpoly) != 0) {
702     /* Error initializing mdata. This often happens when curve is empty */
703     return CDDM_new(0, 0, 0, 0, 0);
704   }
705
706   dm = CDDM_new(totvert, totedge, 0, totloop, totpoly);
707   dm->deformedOnly = 1;
708   dm->dirty |= DM_DIRTY_NORMALS;
709
710   cddm = (CDDerivedMesh *)dm;
711
712   memcpy(cddm->mvert, allvert, totvert * sizeof(MVert));
713   memcpy(cddm->medge, alledge, totedge * sizeof(MEdge));
714   memcpy(cddm->mloop, allloop, totloop * sizeof(MLoop));
715   memcpy(cddm->mpoly, allpoly, totpoly * sizeof(MPoly));
716
717   if (alluv) {
718     const char *uvname = "Orco";
719     CustomData_add_layer_named(&cddm->dm.loopData, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
720   }
721
722   MEM_freeN(allvert);
723   MEM_freeN(alledge);
724   MEM_freeN(allloop);
725   MEM_freeN(allpoly);
726
727   return dm;
728 }
729
730 static void loops_to_customdata_corners(
731     BMesh *bm, CustomData *facedata, int cdindex, const BMLoop *l3[3], int numCol, int numUV)
732 {
733   const BMLoop *l;
734   //  BMFace *f = l3[0]->f;
735   MTFace *texface;
736   MCol *mcol;
737   MLoopCol *mloopcol;
738   MLoopUV *mloopuv;
739   int i, j, hasPCol = CustomData_has_layer(&bm->ldata, CD_PREVIEW_MLOOPCOL);
740
741   for (i = 0; i < numUV; i++) {
742     texface = CustomData_get_n(facedata, CD_MTFACE, cdindex, i);
743
744     for (j = 0; j < 3; j++) {
745       l = l3[j];
746       mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i);
747       copy_v2_v2(texface->uv[j], mloopuv->uv);
748     }
749   }
750
751   for (i = 0; i < numCol; i++) {
752     mcol = CustomData_get_n(facedata, CD_MCOL, cdindex, i);
753
754     for (j = 0; j < 3; j++) {
755       l = l3[j];
756       mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPCOL, i);
757       MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
758     }
759   }
760
761   if (hasPCol) {
762     mcol = CustomData_get(facedata, cdindex, CD_PREVIEW_MCOL);
763
764     for (j = 0; j < 3; j++) {
765       l = l3[j];
766       mloopcol = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_PREVIEW_MLOOPCOL);
767       MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
768     }
769   }
770 }
771
772 /* TODO(campbell): remove, use BKE_mesh_from_bmesh_for_eval_nomain instead. */
773
774 /* used for both editbmesh and bmesh */
775 static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
776                                        const bool use_mdisps,
777                                        /* EditBMesh vars for use_tessface */
778                                        const bool use_tessface,
779                                        const int em_tottri,
780                                        const BMLoop *(*em_looptris)[3])
781 {
782   DerivedMesh *dm = CDDM_new(
783       bm->totvert, bm->totedge, use_tessface ? em_tottri : 0, bm->totloop, bm->totface);
784
785   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
786   BMIter iter;
787   BMVert *eve;
788   BMEdge *eed;
789   BMFace *efa;
790   MVert *mvert = cddm->mvert;
791   MEdge *medge = cddm->medge;
792   MFace *mface = cddm->mface;
793   MLoop *mloop = cddm->mloop;
794   MPoly *mpoly = cddm->mpoly;
795   int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
796   int numUV = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
797   int *index, add_orig;
798   CustomData_MeshMasks mask = {0};
799   unsigned int i, j;
800
801   const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
802   const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
803   const int cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
804
805   dm->deformedOnly = 1;
806
807   /* don't add origindex layer if one already exists */
808   add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
809
810   mask = CD_MASK_DERIVEDMESH;
811   if (use_mdisps) {
812     mask.lmask |= CD_MASK_MDISPS;
813   }
814
815   /* don't process shapekeys, we only feed them through the modifier stack as needed,
816    * e.g. for applying modifiers or the like*/
817   mask.vmask &= ~CD_MASK_SHAPEKEY;
818   CustomData_merge(&bm->vdata, &dm->vertData, mask.vmask, CD_CALLOC, dm->numVertData);
819   CustomData_merge(&bm->edata, &dm->edgeData, mask.emask, CD_CALLOC, dm->numEdgeData);
820   CustomData_merge(&bm->ldata, &dm->loopData, mask.lmask, CD_CALLOC, dm->numLoopData);
821   CustomData_merge(&bm->pdata, &dm->polyData, mask.pmask, CD_CALLOC, dm->numPolyData);
822
823   /* add tessellation mface layers */
824   if (use_tessface) {
825     CustomData_from_bmeshpoly(&dm->faceData, &dm->loopData, em_tottri);
826   }
827
828   index = dm->getVertDataArray(dm, CD_ORIGINDEX);
829
830   BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
831     MVert *mv = &mvert[i];
832
833     copy_v3_v3(mv->co, eve->co);
834
835     BM_elem_index_set(eve, i); /* set_inline */
836
837     normal_float_to_short_v3(mv->no, eve->no);
838
839     mv->flag = BM_vert_flag_to_mflag(eve);
840
841     if (cd_vert_bweight_offset != -1) {
842       mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
843     }
844
845     if (add_orig) {
846       *index++ = i;
847     }
848
849     CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
850   }
851   bm->elem_index_dirty &= ~BM_VERT;
852
853   index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
854   BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
855     MEdge *med = &medge[i];
856
857     BM_elem_index_set(eed, i); /* set_inline */
858
859     med->v1 = BM_elem_index_get(eed->v1);
860     med->v2 = BM_elem_index_get(eed->v2);
861
862     med->flag = BM_edge_flag_to_mflag(eed);
863
864     /* handle this differently to editmode switching,
865      * only enable draw for single user edges rather then calculating angle */
866     if ((med->flag & ME_EDGEDRAW) == 0) {
867       if (eed->l && eed->l == eed->l->radial_next) {
868         med->flag |= ME_EDGEDRAW;
869       }
870     }
871
872     if (cd_edge_crease_offset != -1) {
873       med->crease = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
874     }
875     if (cd_edge_bweight_offset != -1) {
876       med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
877     }
878
879     CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
880     if (add_orig) {
881       *index++ = i;
882     }
883   }
884   bm->elem_index_dirty &= ~BM_EDGE;
885
886   /* avoid this where possiblem, takes extra memory */
887   if (use_tessface) {
888
889     BM_mesh_elem_index_ensure(bm, BM_FACE);
890
891     index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
892     for (i = 0; i < dm->numTessFaceData; i++) {
893       MFace *mf = &mface[i];
894       const BMLoop **l = em_looptris[i];
895       efa = l[0]->f;
896
897       mf->v1 = BM_elem_index_get(l[0]->v);
898       mf->v2 = BM_elem_index_get(l[1]->v);
899       mf->v3 = BM_elem_index_get(l[2]->v);
900       mf->v4 = 0;
901       mf->mat_nr = efa->mat_nr;
902       mf->flag = BM_face_flag_to_mflag(efa);
903
904       /* map mfaces to polygons in the same cddm intentionally */
905       *index++ = BM_elem_index_get(efa);
906
907       loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numUV);
908       test_index_face(mf, &dm->faceData, i, 3);
909     }
910   }
911
912   index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
913   j = 0;
914   BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
915     BMLoop *l_iter;
916     BMLoop *l_first;
917     MPoly *mp = &mpoly[i];
918
919     BM_elem_index_set(efa, i); /* set_inline */
920
921     mp->totloop = efa->len;
922     mp->flag = BM_face_flag_to_mflag(efa);
923     mp->loopstart = j;
924     mp->mat_nr = efa->mat_nr;
925
926     l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
927     do {
928       mloop->v = BM_elem_index_get(l_iter->v);
929       mloop->e = BM_elem_index_get(l_iter->e);
930       CustomData_from_bmesh_block(&bm->ldata, &dm->loopData, l_iter->head.data, j);
931
932       BM_elem_index_set(l_iter, j); /* set_inline */
933
934       j++;
935       mloop++;
936     } while ((l_iter = l_iter->next) != l_first);
937
938     CustomData_from_bmesh_block(&bm->pdata, &dm->polyData, efa->head.data, i);
939
940     if (add_orig) {
941       *index++ = i;
942     }
943   }
944   bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
945
946   dm->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
947
948   return dm;
949 }
950
951 struct DerivedMesh *CDDM_from_bmesh(struct BMesh *bm, const bool use_mdisps)
952 {
953   return cddm_from_bmesh_ex(bm,
954                             use_mdisps,
955                             false,
956                             /* these vars are for editmesh only */
957                             0,
958                             NULL);
959 }
960
961 DerivedMesh *CDDM_from_editbmesh(BMEditMesh *em, const bool use_mdisps, const bool use_tessface)
962 {
963   return cddm_from_bmesh_ex(em->bm,
964                             use_mdisps,
965                             /* editmesh */
966                             use_tessface,
967                             em->tottri,
968                             (const BMLoop *(*)[3])em->looptris);
969 }
970
971 DerivedMesh *CDDM_copy(DerivedMesh *source)
972 {
973   CDDerivedMesh *cddm = cdDM_create("CDDM_copy cddm");
974   DerivedMesh *dm = &cddm->dm;
975   int numVerts = source->numVertData;
976   int numEdges = source->numEdgeData;
977   int numTessFaces = 0;
978   int numLoops = source->numLoopData;
979   int numPolys = source->numPolyData;
980
981   /* NOTE: Don't copy tessellation faces if not requested explicitly. */
982
983   /* ensure these are created if they are made on demand */
984   source->getVertDataArray(source, CD_ORIGINDEX);
985   source->getEdgeDataArray(source, CD_ORIGINDEX);
986   source->getPolyDataArray(source, CD_ORIGINDEX);
987
988   /* this initializes dm, and copies all non mvert/medge/mface layers */
989   DM_from_template(dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys);
990   dm->deformedOnly = source->deformedOnly;
991   dm->cd_flag = source->cd_flag;
992   dm->dirty = source->dirty;
993
994   /* Tessellation data is never copied, so tag it here.
995    * Only tag dirty layers if we really ignored tessellation faces.
996    */
997   dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
998
999   CustomData_copy_data(&source->vertData, &dm->vertData, 0, 0, numVerts);
1000   CustomData_copy_data(&source->edgeData, &dm->edgeData, 0, 0, numEdges);
1001
1002   /* now add mvert/medge/mface layers */
1003   cddm->mvert = source->dupVertArray(source);
1004   cddm->medge = source->dupEdgeArray(source);
1005
1006   CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, cddm->mvert, numVerts);
1007   CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, cddm->medge, numEdges);
1008
1009   DM_DupPolys(source, dm);
1010
1011   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1012   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1013
1014   return dm;
1015 }
1016
1017 /* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
1018  * relationship between mesh data this needs to be set by the caller. */
1019 DerivedMesh *CDDM_from_template_ex(DerivedMesh *source,
1020                                    int numVerts,
1021                                    int numEdges,
1022                                    int numTessFaces,
1023                                    int numLoops,
1024                                    int numPolys,
1025                                    const CustomData_MeshMasks *mask)
1026 {
1027   CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
1028   DerivedMesh *dm = &cddm->dm;
1029
1030   /* ensure these are created if they are made on demand */
1031   source->getVertDataArray(source, CD_ORIGINDEX);
1032   source->getEdgeDataArray(source, CD_ORIGINDEX);
1033   source->getTessFaceDataArray(source, CD_ORIGINDEX);
1034   source->getPolyDataArray(source, CD_ORIGINDEX);
1035
1036   /* this does a copy of all non mvert/medge/mface layers */
1037   DM_from_template_ex(
1038       dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys, mask);
1039
1040   /* now add mvert/medge/mface layers */
1041   CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
1042   CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
1043   CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
1044   CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
1045   CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
1046
1047   if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX)) {
1048     CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
1049   }
1050   if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX)) {
1051     CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
1052   }
1053   if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX)) {
1054     CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
1055   }
1056
1057   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
1058   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
1059   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
1060   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1061   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1062
1063   return dm;
1064 }
1065 DerivedMesh *CDDM_from_template(
1066     DerivedMesh *source, int numVerts, int numEdges, int numTessFaces, int numLoops, int numPolys)
1067 {
1068   return CDDM_from_template_ex(
1069       source, numVerts, numEdges, numTessFaces, numLoops, numPolys, &CD_MASK_DERIVEDMESH);
1070 }
1071
1072 void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
1073 {
1074   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1075   MVert *vert;
1076   int i;
1077
1078   /* this will just return the pointer if it wasn't a referenced layer */
1079   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1080   cddm->mvert = vert;
1081
1082   for (i = 0; i < dm->numVertData; ++i, ++vert) {
1083     copy_v3_v3(vert->co, vertCoords[i]);
1084   }
1085
1086   cddm->dm.dirty |= DM_DIRTY_NORMALS;
1087 }
1088
1089 void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3])
1090 {
1091   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1092   MVert *vert;
1093   int i;
1094
1095   /* this will just return the pointer if it wasn't a referenced layer */
1096   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1097   cddm->mvert = vert;
1098
1099   for (i = 0; i < dm->numVertData; ++i, ++vert) {
1100     copy_v3_v3_short(vert->no, vertNormals[i]);
1101   }
1102
1103   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1104 }
1105
1106 void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const bool only_face_normals)
1107 {
1108   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1109   float(*face_nors)[3] = NULL;
1110
1111   if (dm->numVertData == 0) {
1112     cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1113     return;
1114   }
1115
1116   /* now we skip calculating vertex normals for referenced layer,
1117    * no need to duplicate verts.
1118    * WATCH THIS, bmesh only change!,
1119    * need to take care of the side effects here - campbell */
1120 #if 0
1121   /* we don't want to overwrite any referenced layers */
1122   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1123 #endif
1124
1125 #if 0
1126   if (dm->numTessFaceData == 0) {
1127     /* No tessellation on this mesh yet, need to calculate one.
1128      *
1129      * Important not to update face normals from polys since it
1130      * interferes with assigning the new normal layer in the following code.
1131      */
1132     CDDM_recalc_tessellation_ex(dm, false);
1133   }
1134   else {
1135     /* A tessellation already exists, it should always have a CD_ORIGINDEX */
1136     BLI_assert(CustomData_has_layer(&dm->faceData, CD_ORIGINDEX));
1137     CustomData_free_layers(&dm->faceData, CD_NORMAL, dm->numTessFaceData);
1138   }
1139 #endif
1140
1141   face_nors = MEM_malloc_arrayN(dm->numPolyData, sizeof(*face_nors), "face_nors");
1142
1143   /* calculate face normals */
1144   BKE_mesh_calc_normals_poly(cddm->mvert,
1145                              NULL,
1146                              dm->numVertData,
1147                              CDDM_get_loops(dm),
1148                              CDDM_get_polys(dm),
1149                              dm->numLoopData,
1150                              dm->numPolyData,
1151                              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) {
1175     return;
1176   }
1177
1178   /* we don't want to overwrite any referenced layers */
1179   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1180
1181   /* fill in if it exists */
1182   poly_nors = CustomData_get_layer(&dm->polyData, CD_NORMAL);
1183   if (!poly_nors) {
1184     poly_nors = CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_CALLOC, NULL, dm->numPolyData);
1185   }
1186
1187   BKE_mesh_calc_normals_poly(cddm->mvert,
1188                              dm->numVertData,
1189                              CDDM_get_loops(dm),
1190                              CDDM_get_polys(dm),
1191                              dm->numLoopData,
1192                              dm->numPolyData,
1193                              poly_nors,
1194                              false);
1195
1196   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1197 }
1198 #else
1199
1200 /* poly normal layer is now only for final display */
1201 void CDDM_calc_normals(DerivedMesh *dm)
1202 {
1203   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1204
1205   /* we don't want to overwrite any referenced layers */
1206   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1207
1208   BKE_mesh_calc_normals_poly(cddm->mvert,
1209                              NULL,
1210                              dm->numVertData,
1211                              CDDM_get_loops(dm),
1212                              CDDM_get_polys(dm),
1213                              dm->numLoopData,
1214                              dm->numPolyData,
1215                              NULL,
1216                              false);
1217
1218   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1219 }
1220
1221 #endif
1222
1223 void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
1224 {
1225   CDDM_calc_loop_normals_spacearr(dm, use_split_normals, split_angle, NULL);
1226 }
1227
1228 /* #define DEBUG_CLNORS */
1229 #ifdef DEBUG_CLNORS
1230 #  include "BLI_linklist.h"
1231 #endif
1232
1233 void CDDM_calc_loop_normals_spacearr(DerivedMesh *dm,
1234                                      const bool use_split_normals,
1235                                      const float split_angle,
1236                                      MLoopNorSpaceArray *r_lnors_spacearr)
1237 {
1238   MVert *mverts = dm->getVertArray(dm);
1239   MEdge *medges = dm->getEdgeArray(dm);
1240   MLoop *mloops = dm->getLoopArray(dm);
1241   MPoly *mpolys = dm->getPolyArray(dm);
1242
1243   CustomData *ldata, *pdata;
1244
1245   float(*lnors)[3];
1246   short(*clnor_data)[2];
1247   float(*pnors)[3];
1248
1249   const int numVerts = dm->getNumVerts(dm);
1250   const int numEdges = dm->getNumEdges(dm);
1251   const int numLoops = dm->getNumLoops(dm);
1252   const int numPolys = dm->getNumPolys(dm);
1253
1254   ldata = dm->getLoopDataLayout(dm);
1255   if (CustomData_has_layer(ldata, CD_NORMAL)) {
1256     lnors = CustomData_get_layer(ldata, CD_NORMAL);
1257   }
1258   else {
1259     lnors = CustomData_add_layer(ldata, CD_NORMAL, CD_CALLOC, NULL, numLoops);
1260   }
1261
1262   /* Compute poly (always needed) and vert normals. */
1263   /* Note we can't use DM_ensure_normals, since it won't keep computed poly nors... */
1264   pdata = dm->getPolyDataLayout(dm);
1265   pnors = CustomData_get_layer(pdata, CD_NORMAL);
1266   if (!pnors) {
1267     pnors = CustomData_add_layer(pdata, CD_NORMAL, CD_CALLOC, NULL, numPolys);
1268   }
1269   BKE_mesh_calc_normals_poly(mverts,
1270                              NULL,
1271                              numVerts,
1272                              mloops,
1273                              mpolys,
1274                              numLoops,
1275                              numPolys,
1276                              pnors,
1277                              (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
1278
1279   dm->dirty &= ~DM_DIRTY_NORMALS;
1280
1281   clnor_data = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
1282
1283   BKE_mesh_normals_loop_split(mverts,
1284                               numVerts,
1285                               medges,
1286                               numEdges,
1287                               mloops,
1288                               lnors,
1289                               numLoops,
1290                               mpolys,
1291                               (const float(*)[3])pnors,
1292                               numPolys,
1293                               use_split_normals,
1294                               split_angle,
1295                               r_lnors_spacearr,
1296                               clnor_data,
1297                               NULL);
1298 #ifdef DEBUG_CLNORS
1299   if (r_lnors_spacearr) {
1300     int i;
1301     for (i = 0; i < numLoops; i++) {
1302       if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
1303         LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
1304         printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
1305         print_v3("\tfinal lnor", lnors[i]);
1306         print_v3("\tauto lnor", r_lnors_spacearr->lspacearr[i]->vec_lnor);
1307         print_v3("\tref_vec", r_lnors_spacearr->lspacearr[i]->vec_ref);
1308         printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n",
1309                r_lnors_spacearr->lspacearr[i]->ref_alpha,
1310                r_lnors_spacearr->lspacearr[i]->ref_beta,
1311                r_lnors_spacearr->lspacearr[i]->loops);
1312         printf("\t\t(shared with loops");
1313         while (loops) {
1314           printf(" %d", POINTER_AS_INT(loops->link));
1315           loops = loops->next;
1316         }
1317         printf(")\n");
1318       }
1319       else {
1320         printf("Loop %d has no lnor space\n", i);
1321       }
1322     }
1323   }
1324 #endif
1325 }
1326
1327 void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
1328 {
1329   BLI_assert(numVerts >= 0);
1330   if (numVerts < dm->numVertData) {
1331     CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts);
1332   }
1333
1334   dm->numVertData = numVerts;
1335 }
1336
1337 void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
1338 {
1339   BLI_assert(numEdges >= 0);
1340   if (numEdges < dm->numEdgeData) {
1341     CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges);
1342   }
1343
1344   dm->numEdgeData = numEdges;
1345 }
1346
1347 void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
1348 {
1349   BLI_assert(numTessFaces >= 0);
1350   if (numTessFaces < dm->numTessFaceData) {
1351     CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces);
1352   }
1353
1354   dm->numTessFaceData = numTessFaces;
1355 }
1356
1357 void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
1358 {
1359   BLI_assert(numLoops >= 0);
1360   if (numLoops < dm->numLoopData) {
1361     CustomData_free_elem(&dm->loopData, numLoops, dm->numLoopData - numLoops);
1362   }
1363
1364   dm->numLoopData = numLoops;
1365 }
1366
1367 void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys)
1368 {
1369   BLI_assert(numPolys >= 0);
1370   if (numPolys < dm->numPolyData) {
1371     CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys);
1372   }
1373
1374   dm->numPolyData = numPolys;
1375 }
1376
1377 /* mesh element access functions */
1378
1379 MVert *CDDM_get_vert(DerivedMesh *dm, int index)
1380 {
1381   return &((CDDerivedMesh *)dm)->mvert[index];
1382 }
1383
1384 MEdge *CDDM_get_edge(DerivedMesh *dm, int index)
1385 {
1386   return &((CDDerivedMesh *)dm)->medge[index];
1387 }
1388
1389 MFace *CDDM_get_tessface(DerivedMesh *dm, int index)
1390 {
1391   return &((CDDerivedMesh *)dm)->mface[index];
1392 }
1393
1394 MLoop *CDDM_get_loop(DerivedMesh *dm, int index)
1395 {
1396   return &((CDDerivedMesh *)dm)->mloop[index];
1397 }
1398
1399 MPoly *CDDM_get_poly(DerivedMesh *dm, int index)
1400 {
1401   return &((CDDerivedMesh *)dm)->mpoly[index];
1402 }
1403
1404 /* array access functions */
1405
1406 MVert *CDDM_get_verts(DerivedMesh *dm)
1407 {
1408   return ((CDDerivedMesh *)dm)->mvert;
1409 }
1410
1411 MEdge *CDDM_get_edges(DerivedMesh *dm)
1412 {
1413   return ((CDDerivedMesh *)dm)->medge;
1414 }
1415
1416 MFace *CDDM_get_tessfaces(DerivedMesh *dm)
1417 {
1418   return ((CDDerivedMesh *)dm)->mface;
1419 }
1420
1421 MLoop *CDDM_get_loops(DerivedMesh *dm)
1422 {
1423   return ((CDDerivedMesh *)dm)->mloop;
1424 }
1425
1426 MPoly *CDDM_get_polys(DerivedMesh *dm)
1427 {
1428   return ((CDDerivedMesh *)dm)->mpoly;
1429 }
1430
1431 void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert)
1432 {
1433   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1434
1435   if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
1436     CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData);
1437   }
1438
1439   cddm->mvert = mvert;
1440 }
1441
1442 void CDDM_set_medge(DerivedMesh *dm, MEdge *medge)
1443 {
1444   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1445
1446   if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
1447     CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData);
1448   }
1449
1450   cddm->medge = medge;
1451 }
1452
1453 void CDDM_set_mface(DerivedMesh *dm, MFace *mface)
1454 {
1455   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1456
1457   if (!CustomData_has_layer(&dm->faceData, CD_MFACE)) {
1458     CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData);
1459   }
1460
1461   cddm->mface = mface;
1462 }
1463
1464 void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop)
1465 {
1466   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1467
1468   if (!CustomData_has_layer(&dm->loopData, CD_MLOOP)) {
1469     CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData);
1470   }
1471
1472   cddm->mloop = mloop;
1473 }
1474
1475 void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly)
1476 {
1477   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1478
1479   if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
1480     CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData);
1481   }
1482
1483   cddm->mpoly = mpoly;
1484 }