Cleanup: style, use braces for blenkernel
[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_diffuse_color_set(cddm->pbvh, ob->sculpt->show_diffuse_color);
274     pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
275   }
276
277   /* always build pbvh from original mesh, and only use it for drawing if
278    * this derivedmesh is just original mesh. it's the multires subsurf dm
279    * that this is actually for, to support a pbvh on a modified mesh */
280   if (!cddm->pbvh && ob->type == OB_MESH) {
281     Mesh *me = BKE_object_get_original_mesh(ob);
282     const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
283     MLoopTri *looptri;
284     bool deformed;
285
286     cddm->pbvh = BKE_pbvh_new();
287     cddm->pbvh_draw = can_pbvh_draw(ob, dm);
288
289     looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
290
291     BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
292
293     BKE_pbvh_build_mesh(cddm->pbvh,
294                         me->mpoly,
295                         me->mloop,
296                         me->mvert,
297                         me->totvert,
298                         &me->vdata,
299                         looptri,
300                         looptris_num);
301
302     pbvh_show_diffuse_color_set(cddm->pbvh, ob->sculpt->show_diffuse_color);
303     pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
304
305     deformed = check_sculpt_object_deformed(ob, true);
306
307     if (deformed && ob->derivedDeform) {
308       DerivedMesh *deformdm = ob->derivedDeform;
309       float(*vertCos)[3];
310       int totvert;
311
312       totvert = deformdm->getNumVerts(deformdm);
313       vertCos = MEM_malloc_arrayN(totvert, sizeof(float[3]), "cdDM_getPBVH vertCos");
314       deformdm->getVertCos(deformdm, vertCos);
315       BKE_pbvh_apply_vertCos(cddm->pbvh, vertCos, totvert);
316       MEM_freeN(vertCos);
317     }
318   }
319
320   return cddm->pbvh;
321 }
322
323 static void cdDM_foreachMappedVert(DerivedMesh *dm,
324                                    void (*func)(void *userData,
325                                                 int index,
326                                                 const float co[3],
327                                                 const float no_f[3],
328                                                 const short no_s[3]),
329                                    void *userData,
330                                    DMForeachFlag flag)
331 {
332   MVert *mv = CDDM_get_verts(dm);
333   const int *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
334   int i;
335
336   if (index) {
337     for (i = 0; i < dm->numVertData; i++, mv++) {
338       const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
339       const int orig = *index++;
340       if (orig == ORIGINDEX_NONE) {
341         continue;
342       }
343       func(userData, orig, mv->co, NULL, no);
344     }
345   }
346   else {
347     for (i = 0; i < dm->numVertData; i++, mv++) {
348       const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
349       func(userData, i, mv->co, NULL, no);
350     }
351   }
352 }
353
354 static void cdDM_foreachMappedEdge(
355     DerivedMesh *dm,
356     void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
357     void *userData)
358 {
359   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
360   MVert *mv = cddm->mvert;
361   MEdge *med = cddm->medge;
362   int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
363
364   for (i = 0; i < dm->numEdgeData; i++, med++) {
365     if (index) {
366       orig = *index++;
367       if (orig == ORIGINDEX_NONE) {
368         continue;
369       }
370       func(userData, orig, mv[med->v1].co, mv[med->v2].co);
371     }
372     else {
373       func(userData, i, mv[med->v1].co, mv[med->v2].co);
374     }
375   }
376 }
377
378 static void cdDM_foreachMappedLoop(DerivedMesh *dm,
379                                    void (*func)(void *userData,
380                                                 int vertex_index,
381                                                 int face_index,
382                                                 const float co[3],
383                                                 const float no[3]),
384                                    void *userData,
385                                    DMForeachFlag flag)
386 {
387   /* We can't use dm->getLoopDataLayout(dm) here, 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, since we probably want to switch to looptris ? */
636
637   CustomData_merge(&mesh->vdata, &dm->vertData, cddata_masks.vmask, alloctype, mesh->totvert);
638   CustomData_merge(&mesh->edata, &dm->edgeData, cddata_masks.emask, alloctype, mesh->totedge);
639   CustomData_merge(&mesh->fdata,
640                    &dm->faceData,
641                    cddata_masks.fmask | CD_MASK_ORIGINDEX,
642                    alloctype,
643                    0 /* mesh->totface */);
644   CustomData_merge(&mesh->ldata, &dm->loopData, cddata_masks.lmask, alloctype, mesh->totloop);
645   CustomData_merge(&mesh->pdata, &dm->polyData, cddata_masks.pmask, alloctype, mesh->totpoly);
646
647   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
648   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
649   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
650   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
651 #if 0
652   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
653 #else
654   cddm->mface = NULL;
655 #endif
656
657   /* commented since even when CD_ORIGINDEX was first added this line fails
658    * on the default cube, (after editmode toggle too) - campbell */
659 #if 0
660   BLI_assert(CustomData_has_layer(&cddm->dm.faceData, CD_ORIGINDEX));
661 #endif
662
663   return dm;
664 }
665
666 DerivedMesh *CDDM_from_curve(Object *ob)
667 {
668   ListBase disp = {NULL, NULL};
669
670   if (ob->runtime.curve_cache) {
671     disp = ob->runtime.curve_cache->disp;
672   }
673
674   return CDDM_from_curve_displist(ob, &disp);
675 }
676
677 DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
678 {
679   Curve *cu = (Curve *)ob->data;
680   DerivedMesh *dm;
681   CDDerivedMesh *cddm;
682   MVert *allvert;
683   MEdge *alledge;
684   MLoop *allloop;
685   MPoly *allpoly;
686   MLoopUV *alluv = NULL;
687   int totvert, totedge, totloop, totpoly;
688   bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
689
690   if (BKE_mesh_nurbs_displist_to_mdata(ob,
691                                        dispbase,
692                                        &allvert,
693                                        &totvert,
694                                        &alledge,
695                                        &totedge,
696                                        &allloop,
697                                        &allpoly,
698                                        (use_orco_uv) ? &alluv : NULL,
699                                        &totloop,
700                                        &totpoly) != 0) {
701     /* Error initializing mdata. This often happens when curve is empty */
702     return CDDM_new(0, 0, 0, 0, 0);
703   }
704
705   dm = CDDM_new(totvert, totedge, 0, totloop, totpoly);
706   dm->deformedOnly = 1;
707   dm->dirty |= DM_DIRTY_NORMALS;
708
709   cddm = (CDDerivedMesh *)dm;
710
711   memcpy(cddm->mvert, allvert, totvert * sizeof(MVert));
712   memcpy(cddm->medge, alledge, totedge * sizeof(MEdge));
713   memcpy(cddm->mloop, allloop, totloop * sizeof(MLoop));
714   memcpy(cddm->mpoly, allpoly, totpoly * sizeof(MPoly));
715
716   if (alluv) {
717     const char *uvname = "Orco";
718     CustomData_add_layer_named(&cddm->dm.loopData, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
719   }
720
721   MEM_freeN(allvert);
722   MEM_freeN(alledge);
723   MEM_freeN(allloop);
724   MEM_freeN(allpoly);
725
726   return dm;
727 }
728
729 static void loops_to_customdata_corners(
730     BMesh *bm, CustomData *facedata, int cdindex, const BMLoop *l3[3], int numCol, int numUV)
731 {
732   const BMLoop *l;
733   //  BMFace *f = l3[0]->f;
734   MTFace *texface;
735   MCol *mcol;
736   MLoopCol *mloopcol;
737   MLoopUV *mloopuv;
738   int i, j, hasPCol = CustomData_has_layer(&bm->ldata, CD_PREVIEW_MLOOPCOL);
739
740   for (i = 0; i < numUV; i++) {
741     texface = CustomData_get_n(facedata, CD_MTFACE, cdindex, i);
742
743     for (j = 0; j < 3; j++) {
744       l = l3[j];
745       mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i);
746       copy_v2_v2(texface->uv[j], mloopuv->uv);
747     }
748   }
749
750   for (i = 0; i < numCol; i++) {
751     mcol = CustomData_get_n(facedata, CD_MCOL, cdindex, i);
752
753     for (j = 0; j < 3; j++) {
754       l = l3[j];
755       mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPCOL, i);
756       MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
757     }
758   }
759
760   if (hasPCol) {
761     mcol = CustomData_get(facedata, cdindex, CD_PREVIEW_MCOL);
762
763     for (j = 0; j < 3; j++) {
764       l = l3[j];
765       mloopcol = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_PREVIEW_MLOOPCOL);
766       MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
767     }
768   }
769 }
770
771 /* TODO(campbell): remove, use BKE_mesh_from_bmesh_for_eval_nomain instead. */
772
773 /* used for both editbmesh and bmesh */
774 static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
775                                        const bool use_mdisps,
776                                        /* EditBMesh vars for use_tessface */
777                                        const bool use_tessface,
778                                        const int em_tottri,
779                                        const BMLoop *(*em_looptris)[3])
780 {
781   DerivedMesh *dm = CDDM_new(
782       bm->totvert, bm->totedge, use_tessface ? em_tottri : 0, bm->totloop, bm->totface);
783
784   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
785   BMIter iter;
786   BMVert *eve;
787   BMEdge *eed;
788   BMFace *efa;
789   MVert *mvert = cddm->mvert;
790   MEdge *medge = cddm->medge;
791   MFace *mface = cddm->mface;
792   MLoop *mloop = cddm->mloop;
793   MPoly *mpoly = cddm->mpoly;
794   int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
795   int numUV = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
796   int *index, add_orig;
797   CustomData_MeshMasks mask = {0};
798   unsigned int i, j;
799
800   const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
801   const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
802   const int cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
803
804   dm->deformedOnly = 1;
805
806   /* don't add origindex layer if one already exists */
807   add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
808
809   mask = CD_MASK_DERIVEDMESH;
810   if (use_mdisps) {
811     mask.lmask |= CD_MASK_MDISPS;
812   }
813
814   /* don't process shapekeys, we only feed them through the modifier stack as needed,
815    * e.g. for applying modifiers or the like*/
816   mask.vmask &= ~CD_MASK_SHAPEKEY;
817   CustomData_merge(&bm->vdata, &dm->vertData, mask.vmask, CD_CALLOC, dm->numVertData);
818   CustomData_merge(&bm->edata, &dm->edgeData, mask.emask, CD_CALLOC, dm->numEdgeData);
819   CustomData_merge(&bm->ldata, &dm->loopData, mask.lmask, CD_CALLOC, dm->numLoopData);
820   CustomData_merge(&bm->pdata, &dm->polyData, mask.pmask, CD_CALLOC, dm->numPolyData);
821
822   /* add tessellation mface layers */
823   if (use_tessface) {
824     CustomData_from_bmeshpoly(&dm->faceData, &dm->loopData, em_tottri);
825   }
826
827   index = dm->getVertDataArray(dm, CD_ORIGINDEX);
828
829   BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
830     MVert *mv = &mvert[i];
831
832     copy_v3_v3(mv->co, eve->co);
833
834     BM_elem_index_set(eve, i); /* set_inline */
835
836     normal_float_to_short_v3(mv->no, eve->no);
837
838     mv->flag = BM_vert_flag_to_mflag(eve);
839
840     if (cd_vert_bweight_offset != -1) {
841       mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
842     }
843
844     if (add_orig) {
845       *index++ = i;
846     }
847
848     CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
849   }
850   bm->elem_index_dirty &= ~BM_VERT;
851
852   index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
853   BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
854     MEdge *med = &medge[i];
855
856     BM_elem_index_set(eed, i); /* set_inline */
857
858     med->v1 = BM_elem_index_get(eed->v1);
859     med->v2 = BM_elem_index_get(eed->v2);
860
861     med->flag = BM_edge_flag_to_mflag(eed);
862
863     /* handle this differently to editmode switching,
864      * only enable draw for single user edges rather then calculating angle */
865     if ((med->flag & ME_EDGEDRAW) == 0) {
866       if (eed->l && eed->l == eed->l->radial_next) {
867         med->flag |= ME_EDGEDRAW;
868       }
869     }
870
871     if (cd_edge_crease_offset != -1) {
872       med->crease = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
873     }
874     if (cd_edge_bweight_offset != -1) {
875       med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
876     }
877
878     CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
879     if (add_orig) {
880       *index++ = i;
881     }
882   }
883   bm->elem_index_dirty &= ~BM_EDGE;
884
885   /* avoid this where possiblem, takes extra memory */
886   if (use_tessface) {
887
888     BM_mesh_elem_index_ensure(bm, BM_FACE);
889
890     index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
891     for (i = 0; i < dm->numTessFaceData; i++) {
892       MFace *mf = &mface[i];
893       const BMLoop **l = em_looptris[i];
894       efa = l[0]->f;
895
896       mf->v1 = BM_elem_index_get(l[0]->v);
897       mf->v2 = BM_elem_index_get(l[1]->v);
898       mf->v3 = BM_elem_index_get(l[2]->v);
899       mf->v4 = 0;
900       mf->mat_nr = efa->mat_nr;
901       mf->flag = BM_face_flag_to_mflag(efa);
902
903       /* map mfaces to polygons in the same cddm intentionally */
904       *index++ = BM_elem_index_get(efa);
905
906       loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numUV);
907       test_index_face(mf, &dm->faceData, i, 3);
908     }
909   }
910
911   index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
912   j = 0;
913   BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
914     BMLoop *l_iter;
915     BMLoop *l_first;
916     MPoly *mp = &mpoly[i];
917
918     BM_elem_index_set(efa, i); /* set_inline */
919
920     mp->totloop = efa->len;
921     mp->flag = BM_face_flag_to_mflag(efa);
922     mp->loopstart = j;
923     mp->mat_nr = efa->mat_nr;
924
925     l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
926     do {
927       mloop->v = BM_elem_index_get(l_iter->v);
928       mloop->e = BM_elem_index_get(l_iter->e);
929       CustomData_from_bmesh_block(&bm->ldata, &dm->loopData, l_iter->head.data, j);
930
931       BM_elem_index_set(l_iter, j); /* set_inline */
932
933       j++;
934       mloop++;
935     } while ((l_iter = l_iter->next) != l_first);
936
937     CustomData_from_bmesh_block(&bm->pdata, &dm->polyData, efa->head.data, i);
938
939     if (add_orig) {
940       *index++ = i;
941     }
942   }
943   bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
944
945   dm->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
946
947   return dm;
948 }
949
950 struct DerivedMesh *CDDM_from_bmesh(struct BMesh *bm, const bool use_mdisps)
951 {
952   return cddm_from_bmesh_ex(bm,
953                             use_mdisps,
954                             false,
955                             /* these vars are for editmesh only */
956                             0,
957                             NULL);
958 }
959
960 DerivedMesh *CDDM_from_editbmesh(BMEditMesh *em, const bool use_mdisps, const bool use_tessface)
961 {
962   return cddm_from_bmesh_ex(em->bm,
963                             use_mdisps,
964                             /* editmesh */
965                             use_tessface,
966                             em->tottri,
967                             (const BMLoop *(*)[3])em->looptris);
968 }
969
970 DerivedMesh *CDDM_copy(DerivedMesh *source)
971 {
972   CDDerivedMesh *cddm = cdDM_create("CDDM_copy cddm");
973   DerivedMesh *dm = &cddm->dm;
974   int numVerts = source->numVertData;
975   int numEdges = source->numEdgeData;
976   int numTessFaces = 0;
977   int numLoops = source->numLoopData;
978   int numPolys = source->numPolyData;
979
980   /* NOTE: Don't copy tessellation faces if not requested explicitly. */
981
982   /* ensure these are created if they are made on demand */
983   source->getVertDataArray(source, CD_ORIGINDEX);
984   source->getEdgeDataArray(source, CD_ORIGINDEX);
985   source->getPolyDataArray(source, CD_ORIGINDEX);
986
987   /* this initializes dm, and copies all non mvert/medge/mface layers */
988   DM_from_template(dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys);
989   dm->deformedOnly = source->deformedOnly;
990   dm->cd_flag = source->cd_flag;
991   dm->dirty = source->dirty;
992
993   /* Tessellation data is never copied, so tag it here.
994    * Only tag dirty layers if we really ignored tessellation faces.
995    */
996   dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
997
998   CustomData_copy_data(&source->vertData, &dm->vertData, 0, 0, numVerts);
999   CustomData_copy_data(&source->edgeData, &dm->edgeData, 0, 0, numEdges);
1000
1001   /* now add mvert/medge/mface layers */
1002   cddm->mvert = source->dupVertArray(source);
1003   cddm->medge = source->dupEdgeArray(source);
1004
1005   CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, cddm->mvert, numVerts);
1006   CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, cddm->medge, numEdges);
1007
1008   DM_DupPolys(source, dm);
1009
1010   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1011   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1012
1013   return dm;
1014 }
1015
1016 /* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
1017  * relationship between mesh data this needs to be set by the caller. */
1018 DerivedMesh *CDDM_from_template_ex(DerivedMesh *source,
1019                                    int numVerts,
1020                                    int numEdges,
1021                                    int numTessFaces,
1022                                    int numLoops,
1023                                    int numPolys,
1024                                    const CustomData_MeshMasks *mask)
1025 {
1026   CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
1027   DerivedMesh *dm = &cddm->dm;
1028
1029   /* ensure these are created if they are made on demand */
1030   source->getVertDataArray(source, CD_ORIGINDEX);
1031   source->getEdgeDataArray(source, CD_ORIGINDEX);
1032   source->getTessFaceDataArray(source, CD_ORIGINDEX);
1033   source->getPolyDataArray(source, CD_ORIGINDEX);
1034
1035   /* this does a copy of all non mvert/medge/mface layers */
1036   DM_from_template_ex(
1037       dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys, mask);
1038
1039   /* now add mvert/medge/mface layers */
1040   CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
1041   CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
1042   CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
1043   CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
1044   CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
1045
1046   if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX)) {
1047     CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
1048   }
1049   if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX)) {
1050     CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
1051   }
1052   if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX)) {
1053     CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
1054   }
1055
1056   cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
1057   cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
1058   cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
1059   cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
1060   cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
1061
1062   return dm;
1063 }
1064 DerivedMesh *CDDM_from_template(
1065     DerivedMesh *source, int numVerts, int numEdges, int numTessFaces, int numLoops, int numPolys)
1066 {
1067   return CDDM_from_template_ex(
1068       source, numVerts, numEdges, numTessFaces, numLoops, numPolys, &CD_MASK_DERIVEDMESH);
1069 }
1070
1071 void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
1072 {
1073   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1074   MVert *vert;
1075   int i;
1076
1077   /* this will just return the pointer if it wasn't a referenced layer */
1078   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1079   cddm->mvert = vert;
1080
1081   for (i = 0; i < dm->numVertData; ++i, ++vert) {
1082     copy_v3_v3(vert->co, vertCoords[i]);
1083   }
1084
1085   cddm->dm.dirty |= DM_DIRTY_NORMALS;
1086 }
1087
1088 void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3])
1089 {
1090   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1091   MVert *vert;
1092   int i;
1093
1094   /* this will just return the pointer if it wasn't a referenced layer */
1095   vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1096   cddm->mvert = vert;
1097
1098   for (i = 0; i < dm->numVertData; ++i, ++vert) {
1099     copy_v3_v3_short(vert->no, vertNormals[i]);
1100   }
1101
1102   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1103 }
1104
1105 void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const bool only_face_normals)
1106 {
1107   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1108   float(*face_nors)[3] = NULL;
1109
1110   if (dm->numVertData == 0) {
1111     cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1112     return;
1113   }
1114
1115   /* now we skip calculating vertex normals for referenced layer,
1116    * no need to duplicate verts.
1117    * WATCH THIS, bmesh only change!,
1118    * need to take care of the side effects here - campbell */
1119 #if 0
1120   /* we don't want to overwrite any referenced layers */
1121   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1122 #endif
1123
1124 #if 0
1125   if (dm->numTessFaceData == 0) {
1126     /* No tessellation on this mesh yet, need to calculate one.
1127      *
1128      * Important not to update face normals from polys since it
1129      * interferes with assigning the new normal layer in the following code.
1130      */
1131     CDDM_recalc_tessellation_ex(dm, false);
1132   }
1133   else {
1134     /* A tessellation already exists, it should always have a CD_ORIGINDEX */
1135     BLI_assert(CustomData_has_layer(&dm->faceData, CD_ORIGINDEX));
1136     CustomData_free_layers(&dm->faceData, CD_NORMAL, dm->numTessFaceData);
1137   }
1138 #endif
1139
1140   face_nors = MEM_malloc_arrayN(dm->numPolyData, sizeof(*face_nors), "face_nors");
1141
1142   /* calculate face normals */
1143   BKE_mesh_calc_normals_poly(cddm->mvert,
1144                              NULL,
1145                              dm->numVertData,
1146                              CDDM_get_loops(dm),
1147                              CDDM_get_polys(dm),
1148                              dm->numLoopData,
1149                              dm->numPolyData,
1150                              face_nors,
1151                              only_face_normals);
1152
1153   CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_ASSIGN, face_nors, dm->numPolyData);
1154
1155   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1156 }
1157
1158 void CDDM_calc_normals_mapping(DerivedMesh *dm)
1159 {
1160   /* use this to skip calculating normals on original vert's, this may need to be changed */
1161   const bool only_face_normals = CustomData_is_referenced_layer(&dm->vertData, CD_MVERT);
1162
1163   CDDM_calc_normals_mapping_ex(dm, only_face_normals);
1164 }
1165
1166 #if 0
1167 /* bmesh note: this matches what we have in trunk */
1168 void CDDM_calc_normals(DerivedMesh *dm)
1169 {
1170   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1171   float(*poly_nors)[3];
1172
1173   if (dm->numVertData == 0)
1174     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,
1186                              dm->numVertData,
1187                              CDDM_get_loops(dm),
1188                              CDDM_get_polys(dm),
1189                              dm->numLoopData,
1190                              dm->numPolyData,
1191                              poly_nors,
1192                              false);
1193
1194   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1195 }
1196 #else
1197
1198 /* poly normal layer is now only for final display */
1199 void CDDM_calc_normals(DerivedMesh *dm)
1200 {
1201   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1202
1203   /* we don't want to overwrite any referenced layers */
1204   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
1205
1206   BKE_mesh_calc_normals_poly(cddm->mvert,
1207                              NULL,
1208                              dm->numVertData,
1209                              CDDM_get_loops(dm),
1210                              CDDM_get_polys(dm),
1211                              dm->numLoopData,
1212                              dm->numPolyData,
1213                              NULL,
1214                              false);
1215
1216   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
1217 }
1218
1219 #endif
1220
1221 void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
1222 {
1223   CDDM_calc_loop_normals_spacearr(dm, use_split_normals, split_angle, NULL);
1224 }
1225
1226 /* #define DEBUG_CLNORS */
1227 #ifdef DEBUG_CLNORS
1228 #  include "BLI_linklist.h"
1229 #endif
1230
1231 void CDDM_calc_loop_normals_spacearr(DerivedMesh *dm,
1232                                      const bool use_split_normals,
1233                                      const float split_angle,
1234                                      MLoopNorSpaceArray *r_lnors_spacearr)
1235 {
1236   MVert *mverts = dm->getVertArray(dm);
1237   MEdge *medges = dm->getEdgeArray(dm);
1238   MLoop *mloops = dm->getLoopArray(dm);
1239   MPoly *mpolys = dm->getPolyArray(dm);
1240
1241   CustomData *ldata, *pdata;
1242
1243   float(*lnors)[3];
1244   short(*clnor_data)[2];
1245   float(*pnors)[3];
1246
1247   const int numVerts = dm->getNumVerts(dm);
1248   const int numEdges = dm->getNumEdges(dm);
1249   const int numLoops = dm->getNumLoops(dm);
1250   const int numPolys = dm->getNumPolys(dm);
1251
1252   ldata = dm->getLoopDataLayout(dm);
1253   if (CustomData_has_layer(ldata, CD_NORMAL)) {
1254     lnors = CustomData_get_layer(ldata, CD_NORMAL);
1255   }
1256   else {
1257     lnors = CustomData_add_layer(ldata, CD_NORMAL, CD_CALLOC, NULL, numLoops);
1258   }
1259
1260   /* Compute poly (always needed) and vert normals. */
1261   /* Note we can't use DM_ensure_normals, since it won't keep computed poly nors... */
1262   pdata = dm->getPolyDataLayout(dm);
1263   pnors = CustomData_get_layer(pdata, CD_NORMAL);
1264   if (!pnors) {
1265     pnors = CustomData_add_layer(pdata, CD_NORMAL, CD_CALLOC, NULL, numPolys);
1266   }
1267   BKE_mesh_calc_normals_poly(mverts,
1268                              NULL,
1269                              numVerts,
1270                              mloops,
1271                              mpolys,
1272                              numLoops,
1273                              numPolys,
1274                              pnors,
1275                              (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
1276
1277   dm->dirty &= ~DM_DIRTY_NORMALS;
1278
1279   clnor_data = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
1280
1281   BKE_mesh_normals_loop_split(mverts,
1282                               numVerts,
1283                               medges,
1284                               numEdges,
1285                               mloops,
1286                               lnors,
1287                               numLoops,
1288                               mpolys,
1289                               (const float(*)[3])pnors,
1290                               numPolys,
1291                               use_split_normals,
1292                               split_angle,
1293                               r_lnors_spacearr,
1294                               clnor_data,
1295                               NULL);
1296 #ifdef DEBUG_CLNORS
1297   if (r_lnors_spacearr) {
1298     int i;
1299     for (i = 0; i < numLoops; i++) {
1300       if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
1301         LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
1302         printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
1303         print_v3("\tfinal lnor", lnors[i]);
1304         print_v3("\tauto lnor", r_lnors_spacearr->lspacearr[i]->vec_lnor);
1305         print_v3("\tref_vec", r_lnors_spacearr->lspacearr[i]->vec_ref);
1306         printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n",
1307                r_lnors_spacearr->lspacearr[i]->ref_alpha,
1308                r_lnors_spacearr->lspacearr[i]->ref_beta,
1309                r_lnors_spacearr->lspacearr[i]->loops);
1310         printf("\t\t(shared with loops");
1311         while (loops) {
1312           printf(" %d", POINTER_AS_INT(loops->link));
1313           loops = loops->next;
1314         }
1315         printf(")\n");
1316       }
1317       else {
1318         printf("Loop %d has no lnor space\n", i);
1319       }
1320     }
1321   }
1322 #endif
1323 }
1324
1325 void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
1326 {
1327   BLI_assert(numVerts >= 0);
1328   if (numVerts < dm->numVertData) {
1329     CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts);
1330   }
1331
1332   dm->numVertData = numVerts;
1333 }
1334
1335 void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
1336 {
1337   BLI_assert(numEdges >= 0);
1338   if (numEdges < dm->numEdgeData) {
1339     CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges);
1340   }
1341
1342   dm->numEdgeData = numEdges;
1343 }
1344
1345 void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
1346 {
1347   BLI_assert(numTessFaces >= 0);
1348   if (numTessFaces < dm->numTessFaceData) {
1349     CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces);
1350   }
1351
1352   dm->numTessFaceData = numTessFaces;
1353 }
1354
1355 void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
1356 {
1357   BLI_assert(numLoops >= 0);
1358   if (numLoops < dm->numLoopData) {
1359     CustomData_free_elem(&dm->loopData, numLoops, dm->numLoopData - numLoops);
1360   }
1361
1362   dm->numLoopData = numLoops;
1363 }
1364
1365 void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys)
1366 {
1367   BLI_assert(numPolys >= 0);
1368   if (numPolys < dm->numPolyData) {
1369     CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys);
1370   }
1371
1372   dm->numPolyData = numPolys;
1373 }
1374
1375 /* mesh element access functions */
1376
1377 MVert *CDDM_get_vert(DerivedMesh *dm, int index)
1378 {
1379   return &((CDDerivedMesh *)dm)->mvert[index];
1380 }
1381
1382 MEdge *CDDM_get_edge(DerivedMesh *dm, int index)
1383 {
1384   return &((CDDerivedMesh *)dm)->medge[index];
1385 }
1386
1387 MFace *CDDM_get_tessface(DerivedMesh *dm, int index)
1388 {
1389   return &((CDDerivedMesh *)dm)->mface[index];
1390 }
1391
1392 MLoop *CDDM_get_loop(DerivedMesh *dm, int index)
1393 {
1394   return &((CDDerivedMesh *)dm)->mloop[index];
1395 }
1396
1397 MPoly *CDDM_get_poly(DerivedMesh *dm, int index)
1398 {
1399   return &((CDDerivedMesh *)dm)->mpoly[index];
1400 }
1401
1402 /* array access functions */
1403
1404 MVert *CDDM_get_verts(DerivedMesh *dm)
1405 {
1406   return ((CDDerivedMesh *)dm)->mvert;
1407 }
1408
1409 MEdge *CDDM_get_edges(DerivedMesh *dm)
1410 {
1411   return ((CDDerivedMesh *)dm)->medge;
1412 }
1413
1414 MFace *CDDM_get_tessfaces(DerivedMesh *dm)
1415 {
1416   return ((CDDerivedMesh *)dm)->mface;
1417 }
1418
1419 MLoop *CDDM_get_loops(DerivedMesh *dm)
1420 {
1421   return ((CDDerivedMesh *)dm)->mloop;
1422 }
1423
1424 MPoly *CDDM_get_polys(DerivedMesh *dm)
1425 {
1426   return ((CDDerivedMesh *)dm)->mpoly;
1427 }
1428
1429 void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert)
1430 {
1431   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1432
1433   if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
1434     CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData);
1435   }
1436
1437   cddm->mvert = mvert;
1438 }
1439
1440 void CDDM_set_medge(DerivedMesh *dm, MEdge *medge)
1441 {
1442   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1443
1444   if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
1445     CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData);
1446   }
1447
1448   cddm->medge = medge;
1449 }
1450
1451 void CDDM_set_mface(DerivedMesh *dm, MFace *mface)
1452 {
1453   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1454
1455   if (!CustomData_has_layer(&dm->faceData, CD_MFACE)) {
1456     CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData);
1457   }
1458
1459   cddm->mface = mface;
1460 }
1461
1462 void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop)
1463 {
1464   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1465
1466   if (!CustomData_has_layer(&dm->loopData, CD_MLOOP)) {
1467     CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData);
1468   }
1469
1470   cddm->mloop = mloop;
1471 }
1472
1473 void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly)
1474 {
1475   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1476
1477   if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
1478     CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData);
1479   }
1480
1481   cddm->mpoly = mpoly;
1482 }