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