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