12b5f55f9eeb5acea9f496964554188da1d3e937
[blender.git] / source / blender / bmesh / intern / editmesh_to_bmesh.c
1 #include "MEM_guardedalloc.h"
2 #include "BKE_customdata.h" 
3 #include "DNA_listBase.h"
4 #include "DNA_meshdata_types.h"
5 #include "DNA_object_types.h"
6 #include "DNA_scene_types.h"
7 #include <string.h>
8 #include "BKE_utildefines.h"
9 #include "BKE_mesh.h"
10 #include "BKE_global.h"
11 #include "BKE_DerivedMesh.h"
12 #include "BKE_cdderivedmesh.h"
13
14 #include "BLI_editVert.h"
15 #include "mesh_intern.h"
16 #include "ED_mesh.h"
17
18 #include "BLI_blenlib.h"
19 #include "BLI_edgehash.h"
20
21 #include "bmesh.h"
22
23 /*
24  * EDITMESH TO BMESH.C
25  *
26  * This file contains functions
27  * for converting an editmesh
28  * into a Bmesh
29  *
30 */
31
32 /*
33  * EDITMESH CORNERS TO LOOPS
34  * 
35  * Converts editmesh face corner data
36  * (UVs, Vert colors, ect) to N-Gon 
37  * face-edge ('loop') data.
38  *
39 */
40
41 static void editmesh_corners_to_loops(BMesh *bm, CustomData *facedata, void *face_block, BMFace *f,int numCol, int numTex){
42         int i, j;
43         BMLoop *l;
44         MTFace *texface;
45         MTexPoly *texpoly;
46         MCol *mcol;
47         MLoopCol *mloopcol;
48         MLoopUV *mloopuv;
49         BMIter iter;
50
51         for(i=0; i < numTex; i++){
52                 texface = CustomData_em_get_n(facedata, face_block, CD_MTFACE, i);
53                 texpoly = CustomData_bmesh_get_n(&bm->pdata, f->data, CD_MTEXPOLY, i);
54                 
55                 texpoly->tpage = texface->tpage;
56                 texpoly->flag = texface->flag;
57                 texpoly->transp = texface->transp;
58                 texpoly->mode = texface->mode;
59                 texpoly->tile = texface->tile;
60                 texpoly->unwrap = texface->unwrap;
61                 
62                 for (j=0, l=BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); l; j++, l=BMIter_Step(&iter)) {
63                         mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->data, CD_MLOOPUV, i);
64                         mloopuv->uv[0] = texface->uv[j][0];
65                         mloopuv->uv[1] = texface->uv[j][1];
66                 }
67
68         }
69         for(i=0; i < numCol; i++){
70                 mcol = CustomData_em_get_n(facedata, face_block, CD_MCOL, i);
71                 for (j=0, l=BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); l; j++, l=BMIter_Step(&iter)) {
72                         mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->data, CD_MLOOPCOL, i);
73                         mloopcol->r = mcol[j].r;
74                         mloopcol->g = mcol[j].g;
75                         mloopcol->b = mcol[j].b;
76                         mloopcol->a = mcol[j].a;
77                 }
78         }
79 }
80
81 /*
82  * EDITVERT TO BMVert
83  *
84  * Converts an editvert to
85  * a BMVert.
86  *
87 */
88
89 static BMVert *editvert_to_BMVert(BMesh *bm, EditMesh *em, EditVert *eve)
90 {
91                 BMVert *v = NULL;
92
93                 v = BM_Make_Vert(bm, eve->co, NULL);
94                 VECCOPY(v->no, eve->no);
95
96                 /*transfer flags*/
97                 v->head.flag = eve->h ? BM_HIDDEN : 0;
98                 if(eve->f & SELECT) BM_Select_Vert(bm, v, 1);
99                 v->bweight = eve->bweight;
100
101                 /*Copy Custom Data*/
102                 CustomData_bmesh_copy_data(&em->vdata, &bm->vdata, eve->data, &v->data);
103                 
104                 return v;
105 }       
106
107 /*
108  * EDITEDGE TO BMEdge
109  *
110  * Converts an editedge to 
111  * a BMEdge
112  *
113 */
114
115 static void editedge_to_BMEdge_internal(BMesh *bm, EditMesh *em, BMEdge *e, EditEdge *eed)
116 {
117         e->crease = eed->crease;
118         e->bweight = eed->bweight;
119         
120         e->head.flag = eed->f & SELECT ? BM_SELECT : 0;
121         e->head.flag |= eed->seam ? BM_SEAM : 0;
122         e->head.flag |= eed->h & 1 ? BM_HIDDEN : 0;
123         e->head.flag |= eed->h & EM_FGON ? BM_FGON : 0;
124         e->head.flag |= eed->sharp ? BM_SHARP : 0;
125
126         CustomData_bmesh_copy_data(&em->edata, &bm->edata, eed->data, &e->data);
127 }
128
129 static BMEdge *editedge_to_BMEdge(BMesh *bm, EditMesh *em, EditEdge *eed)
130 {
131                 BMVert *v1 = NULL, *v2 = NULL;
132                 BMEdge *e = NULL;
133                 
134                 v1 = eed->v1->tmp.p;
135                 v2 = eed->v2->tmp.p;
136         
137                 e = BM_Make_Edge(bm, v1, v2,NULL, 0); 
138
139                 editedge_to_BMEdge_internal(bm, em, e, eed);
140
141                 return e;
142 }
143 /*
144  * EDITFACE TO BMFace
145  *
146  * Converts an editface to a BMFace.
147  * Note that this also convert per-face
148  * corner data as well.
149  *
150 */
151
152 static BMFace *editface_to_BMFace(BMesh *bm, EditMesh *em, EditFace *efa, int numCol, int numTex)
153 {
154                 BMVert *v1 = NULL, *v2 = NULL;
155                 BMFace *f = NULL;
156                 BMEdge *edar[4];
157                 int len;
158
159                 edar[0] = BM_Make_Edge(bm, efa->v1->tmp.p, efa->v2->tmp.p, NULL, 1); 
160                 edar[1] = BM_Make_Edge(bm, efa->v2->tmp.p, efa->v3->tmp.p, NULL, 1); 
161                 if(efa->v4){
162                         edar[2] = BM_Make_Edge(bm, efa->v3->tmp.p, efa->v4->tmp.p, NULL, 1); 
163                         edar[3] = BM_Make_Edge(bm, efa->v4->tmp.p, efa->v1->tmp.p, NULL, 1); 
164                 }else{
165                         edar[2] = BM_Make_Edge(bm, efa->v3->tmp.p, efa->v1->tmp.p, NULL, 1); 
166                 }
167
168                 editedge_to_BMEdge_internal(bm, em, edar[0], efa->e1);
169                 editedge_to_BMEdge_internal(bm, em, edar[1], efa->e2);
170                 editedge_to_BMEdge_internal(bm, em, edar[2], efa->e3);
171                 if(efa->v4)
172                         editedge_to_BMEdge_internal(bm, em, edar[3], efa->e4);
173
174
175                 if(efa->e1->fgoni) edar[0]->head.flag |= BM_FGON;
176                 if(efa->e2->fgoni) edar[1]->head.flag |= BM_FGON;
177                 if(efa->e3->fgoni) edar[2]->head.flag |= BM_FGON;
178                 if(efa->v4 && efa->e4->fgoni) edar[3]->head.flag |= BM_FGON;
179
180                 if(efa->v4) len = 4;
181                 else len = 3;
182
183                 /*find v1 and v2*/
184                 v1 = efa->v1->tmp.p;
185                 v2 = efa->v2->tmp.p;
186
187                 f = BM_Make_Ngon(bm, v1, v2, edar, len, 0);
188                 f->head.flag = 0;
189                 f->mat_nr = efa->mat_nr;
190                 if(efa->f & SELECT) BM_Select_Face(bm, f, 1);
191                 if(efa->h) f->head.flag |= BM_HIDDEN;
192                 
193                 CustomData_bmesh_copy_data(&em->fdata, &bm->pdata, efa->data, &f->data);
194                 editmesh_corners_to_loops(bm, &em->fdata, efa->data, f,numCol,numTex);
195
196                 return f;
197 }
198
199 /*
200  * BMESH FGONCONVERT
201  *
202  * This function and its associated structures
203  * /helpers (fgonsort, sortfgon, fuse_fgon) are
204  * used to convert f-gons to bmesh n-gons. This
205  * is accomplished by sorting a list of fgon faces
206  * such that faces that are part of the same fgon
207  * are next to each other. These faces are then
208  * converted as is into bmesh faces and
209  * fused togather.
210  *
211  * Note that currently, there is no support for 
212  * holes in faces in the bmesh structure, so 
213  * f-gons with holes will only partially convert.
214  *
215 */
216
217 typedef struct fgonsort {
218         unsigned long x;
219         struct EditFace *efa;
220         struct BMFace *f;
221         int done;
222 }fgonsort;
223
224 static int sortfgon(const void *v1, const void *v2)
225 {
226         const struct fgonsort *x1=v1, *x2=v2;
227         
228         if( x1->x > x2->x ) return 1;
229         else if( x1->x < x2->x) return -1;
230         return 0;
231 }
232
233 static void fuse_fgon(BMesh *bm, BMFace *f)
234 {
235         BMFace *sf;
236         BMLoop *l;
237         int done;
238
239         sf = f;
240         done = 0;
241         while(!done){
242                 done = 1;
243                 l = sf->loopbase;
244                 do{
245                         if(l->e->head.flag & BM_FGON){ 
246                                 sf = BM_Join_Faces(bm,l->f, ((BMLoop*)l->radial.next->data)->f, l->e, 0,0);
247                                 if(sf){
248                                         done = 0;
249                                         break;
250                                 } else { /*we have to get out of here...*/
251                                         return;
252                                 }
253                         }
254                         l = ((BMLoop*)(l->head.next));
255                 }while(l != sf->loopbase);
256         }
257 }
258
259 static BM_fgonconvert(BMesh *bm, EditMesh *em, int numCol, int numTex)
260 {
261         EditFace *efa;
262         struct fgonsort *sortblock, *sb, *sb1;
263         int a, b, amount=0;
264
265         /*zero out efa->tmp, we store fgon index here*/
266         for(efa = em->faces.first; efa; efa = efa->next){ 
267                 efa->tmp.l = 0;
268                 amount++;
269         }
270         /*go through and give each editface an fgon index*/
271         for(efa = em->faces.first; efa; efa = efa->next){
272                 if(efa->e1->fgoni) efa->tmp.l = efa->e1->fgoni;
273                 else if(efa->e2->fgoni) efa->tmp.l = efa->e2->fgoni;
274                 else if(efa->e3->fgoni) efa->tmp.l = efa->e3->fgoni;
275                 else if(efa->e4 && efa->e4->fgoni) efa->tmp.l = efa->e4->fgoni;
276         }
277
278         sb= sortblock= MEM_mallocN(sizeof(fgonsort)* amount,"fgon sort block");
279
280         for(efa = em->faces.first; efa; efa=efa->next){
281                 sb->x = efa->tmp.l;
282                 sb->efa = efa;
283                 sb->done = 0;
284                 sb++;
285         }
286
287         qsort(sortblock, amount, sizeof(fgonsort), sortfgon);
288
289         sb = sortblock;
290         for(a=0; a<amount; a++, sb++) {
291                 if(sb->x && sb->done == 0){
292                         /*first pass: add in faces for this fgon*/
293                         for(b=a, sb1 = sb; b<amount && sb1->x == sb->x; b++, sb1++){
294                                 efa = sb1->efa;
295                                 sb1->f = editface_to_BMFace(bm, em, efa, numCol, numTex);
296                                 sb1->done = 1;
297                         }
298                         /*fuse fgon*/
299                         fuse_fgon(bm, sb->f);
300                 }
301         }
302         MEM_freeN(sortblock);
303 }
304
305 /*
306  * TAG WIRE EDGES
307  *
308  * Flags editedges 'f1' member
309  * if the edge has no faces.
310  *
311 */
312
313 static void tag_wire_edges(EditMesh *em){
314         EditFace *efa;
315         EditEdge *eed;
316         for(eed = em->edges.first; eed; eed = eed->next) eed->f1 = 1;
317         for(efa = em->faces.first; efa; efa = efa->next){
318                 efa->e1->f1 = 0;
319                 efa->e2->f1 = 0;
320                 efa->e3->f1 = 0;
321                 if(efa->e4) efa->e4->f1 = 0;
322         }
323 }
324
325 /*
326  * EDITMESH TO BMESH
327  *
328  * Function to convert an editmesh to a bmesh
329  * Currently all custom data as well as 
330  * f-gons should be converted correctly.
331  *
332 */
333
334 BMesh *editmesh_to_bmesh_intern(EditMesh *em, BMesh *bm) {
335         BMVert *v;
336         EditVert *eve;
337         EditEdge *eed;
338         EditFace *efa;
339         int allocsize[4] = {512,512,2048,512}, numTex, numCol;
340
341         /*make sure to update FGon flags*/
342         EM_fgon_flags(em);
343
344         /*copy custom data layout*/
345         CustomData_copy(&em->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
346         CustomData_copy(&em->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
347         CustomData_copy(&em->fdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
348
349         /*copy face corner data*/
350         CustomData_to_bmeshpoly(&em->fdata, &bm->pdata, &bm->ldata);
351         /*initialize memory pools*/
352         CustomData_bmesh_init_pool(&bm->vdata, allocsize[0]);
353         CustomData_bmesh_init_pool(&bm->edata, allocsize[1]);
354         CustomData_bmesh_init_pool(&bm->ldata, allocsize[2]);
355         CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]);
356         /*needed later*/
357         numTex = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
358         numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
359
360         /*copy over selection mode*/
361         bm->selectmode = 0;
362         if(em->selectmode & SCE_SELECT_VERTEX) bm->selectmode |= BM_VERT;
363         if(em->selectmode & SCE_SELECT_EDGE) bm->selectmode |= BM_EDGE;
364         if(em->selectmode & SCE_SELECT_FACE) bm->selectmode |= BM_FACE;
365
366
367         /*begin editloop*/
368         //BM_Begin_Edit(bm);
369
370         /*tag wire edges*/
371         tag_wire_edges(em);
372
373         /*add verts*/
374         for(eve = em->verts.first; eve; eve = eve->next){
375                 v = editvert_to_BMVert(bm, em, eve);
376                 eve->tmp.p = v;
377         }
378         /*convert f-gons*/
379         BM_fgonconvert(bm, em, numCol, numTex);
380         
381         /*do quads + triangles*/
382         for(efa = em->faces.first; efa; efa = efa->next){
383                 if(!efa->tmp.l) editface_to_BMFace(bm, em, efa, numCol, numTex);
384         }
385
386         /*add wire edges*/      
387         for(eed = em->edges.first; eed; eed = eed->next){
388                 if(eed->f1) editedge_to_BMEdge(bm, em, eed);
389         }
390         //BM_end_edit(bm, BM_CALC_NORM);
391         return bm;
392 }
393
394 void edit2bmesh_exec(BMesh *bmesh, BMOperator *op)
395 {
396         editmesh_to_bmesh_intern(op->slots[BMOP_FROM_EDITMESH_EM].data.p, bmesh);
397 }
398
399 BMesh *editmesh_to_bmesh(EditMesh *em)
400 {
401         BMOperator conv;
402         BMesh *bm;
403         int allocsize[4] = {512,512,2048,512}, numTex, numCol;
404
405         /*allocate a bmesh*/
406         bm = BM_Make_Mesh(allocsize);
407
408         BMO_Init_Op(&conv, BMOP_FROM_EDITMESH);
409         BMO_Set_Pnt(&conv, BMOP_FROM_EDITMESH_EM, em);
410         BMO_Exec_Op(bm, &conv);
411         BMO_Finish_Op(bm, &conv);
412
413         return bm;
414 }