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