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