first pass at the uv code. uv editor now mostly uses new bmesh structures for uvs.
[blender-staging.git] / source / blender / bmesh / operators / mesh_conv.c
1
2 #include "MEM_guardedalloc.h"
3 #include "BKE_customdata.h" 
4 #include "DNA_listBase.h"
5 #include "DNA_customdata_types.h"
6 #include "DNA_mesh_types.h"
7 #include "DNA_meshdata_types.h"
8 #include "DNA_object_types.h"
9 #include "DNA_scene_types.h"
10 #include <string.h>
11 #include "BKE_utildefines.h"
12 #include "BKE_mesh.h"
13 #include "BKE_global.h"
14 #include "BKE_DerivedMesh.h"
15 #include "BKE_cdderivedmesh.h"
16
17 #include "BLI_editVert.h"
18 #include "mesh_intern.h"
19 #include "ED_mesh.h"
20
21 #include "BLI_blenlib.h"
22 #include "BLI_edgehash.h"
23
24 #include "bmesh.h"
25
26 /*
27  * MESH CONV.C
28  *
29  * This file contains functions
30  * for converting a Mesh
31  * into a Bmesh.  will not support non-ngon
32  * meshes at first, use the editmesh functions
33  * until it's implemented, and remove this
34  * comment if it already is. -joeedh
35  *
36 */
37
38 void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) {
39         Mesh *me = BMO_Get_Pnt(op, "mesh");
40         MVert *mvert;
41         MEdge *medge;
42         MLoop *ml;
43         MPoly *mpoly;
44         BMVert *v, **vt=NULL;
45         BMEdge *e, **fedges=NULL, **et;
46         V_DECLARE(fedges);
47         BMFace *f;
48         int i, j, li, allocsize[4] = {512, 512, 2048, 512};
49
50         if (!me || !me->totvert) return; /*sanity check*/
51         
52         mvert = me->mvert;
53
54         vt = MEM_mallocN(sizeof(void**)*me->totvert, "mesh to bmesh vtable");
55
56         CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
57         CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
58         CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
59         CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
60
61         CustomData_bmesh_init_pool(&bm->vdata, allocsize[0]);
62         CustomData_bmesh_init_pool(&bm->edata, allocsize[1]);
63         CustomData_bmesh_init_pool(&bm->ldata, allocsize[2]);
64         CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]);
65
66         for (i=0; i<me->totvert; i++, mvert++) {
67                 v = BM_Make_Vert(bm, mvert->co, NULL);
68                 VECCOPY(v->no, mvert->no);
69
70                 vt[i] = v;
71                 BMINDEX_SET(v, i);
72
73                 /*transfer flags*/
74                 v->head.flag = (mvert->flag & ME_HIDE) ? BM_HIDDEN : 0;
75                 if(mvert->flag & SELECT) BM_Select_Vert(bm, v, 1);
76                 v->bweight = (float)mvert->bweight / 255.0f;
77
78                 /*Copy Custom Data*/
79                 CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
80
81                 v->head.flag = MEFlags_To_BMFlags(mvert->flag, BM_VERT);
82         }
83
84         if (!me->totedge) return;
85
86         et = MEM_mallocN(sizeof(void**)*me->totedge, "mesh to bmesh etable");
87
88         medge = me->medge;
89         for (i=0; i<me->totedge; i++, medge++) {
90                 e = BM_Make_Edge(bm, vt[medge->v1], vt[medge->v2], NULL, 0);
91                 et[i] = e;
92                 
93                 /*Copy Custom Data*/
94                 CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
95                 
96                 e->crease = (float)medge->crease / 255.0f;
97                 e->bweight = (float)medge->bweight / 255.0f;
98
99                 e->head.flag = MEFlags_To_BMFlags(medge->flag, BM_EDGE);
100         }
101         
102         if (!me->totpoly) return;
103
104         mpoly = me->mpoly;
105         li = 0;
106         for (i=0; i<me->totpoly; i++, mpoly++) {
107                 BMVert *v1, *v2;
108                 BMIter iter;
109                 BMLoop *l;
110
111                 V_RESET(fedges);
112                 for (j=0; j<mpoly->totloop; j++) {
113                         ml = &me->mloop[mpoly->loopstart+j];
114                         v = vt[ml->v];
115                         e = et[ml->e];
116
117                         V_GROW(fedges);
118
119                         fedges[j] = e;
120                 }
121                 
122                 v1 = vt[me->mloop[mpoly->loopstart].v];
123                 v2 = vt[me->mloop[mpoly->loopstart+1].v];
124
125                 if (v1 == fedges[0]->v1) v2 = fedges[0]->v2;
126                 else {
127                         v1 = fedges[0]->v2;
128                         v2 = fedges[0]->v1;
129                 }
130
131                 f = BM_Make_Ngon(bm, v1, v2, fedges, mpoly->totloop, 0);
132                 
133                 f->head.flag = MEFlags_To_BMFlags(mpoly->flag, BM_FACE);
134                 f->mat_nr = mpoly->mat_nr;
135                 if (i == me->act_face) bm->act_face = f;
136
137                 /*Copy over loop customdata*/
138                 BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
139                         CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
140                         li++;
141                 }
142
143                 /*Copy Custom Data*/
144                 CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
145         }
146
147         V_FREE(fedges);
148 }
149
150 void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) {
151         BMesh *bmtess;
152         Object *ob = BMO_Get_Pnt(op, "object");
153         Scene *scene = BMO_Get_Pnt(op, "scene");
154         Mesh *me = ob->data;
155         MLoop *mloop;
156         MPoly *mpoly;
157         MVert *mvert, *oldverts;
158         MEdge *medge;
159         MFace *mface;
160         BMVert *v;
161         BMEdge *e;
162         BMLoop *l;
163         BMFace *f;
164         BMIter iter, liter;
165         int i, j, ototvert, totloop, numTex, numCol;
166         
167         numTex = CustomData_number_of_layers(&me->pdata, CD_MLOOPUV);
168         numCol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
169
170         bmtess = BM_Copy_Mesh(bm);
171         BMO_CallOpf(bmtess, "makefgon trifan=%i", 0);
172         
173         /* new Vertex block */
174         if(bm->totvert==0) mvert= NULL;
175         else mvert= MEM_callocN(bm->totvert*sizeof(MVert), "loadeditbMesh vert");
176
177         /* new Edge block */
178         if(bm->totedge==0) medge= NULL;
179         else medge= MEM_callocN(bm->totedge*sizeof(MEdge), "loadeditbMesh edge");
180         
181         /* new Face block */
182         if(bmtess->totface==0) mface= NULL;
183         else mface= MEM_callocN(bmtess->totface*sizeof(MFace), "loadeditbMesh face");
184
185         /*build ngon data*/
186         /* new Ngon Face block */
187         if(bm->totface==0) mpoly = NULL;
188         else mpoly= MEM_callocN(bm->totface*sizeof(MPoly), "loadeditbMesh poly");
189         
190         /*find number of loops to allocate*/
191         totloop = 0;
192         BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
193                 totloop += f->len;
194         }
195
196         if (totloop==0) mloop = NULL;
197         else mloop = MEM_callocN(totloop*sizeof(MLoop), "loadeditbMesh loop");
198
199         /* lets save the old verts just in case we are actually working on
200          * a key ... we now do processing of the keys at the end */
201         oldverts= me->mvert;
202
203         /* don't free this yet */
204         CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
205
206         /* free custom data */
207         CustomData_free(&me->vdata, me->totvert);
208         CustomData_free(&me->edata, me->totedge);
209         CustomData_free(&me->fdata, me->totface);
210         CustomData_free(&me->ldata, me->totloop);
211         CustomData_free(&me->pdata, me->totpoly);
212
213         /* add new custom data */
214         me->totvert= bm->totvert;
215         me->totedge= bm->totedge;
216         me->totface= bmtess->totface;
217         me->totloop= totloop;
218         me->totpoly= bm->totface;
219
220         CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
221         CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
222         CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
223         CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
224
225         CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
226         CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
227         CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN, mface, me->totface);
228         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
229         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
230
231         CustomData_from_bmeshpoly(&me->fdata, &bmtess->pdata, &bmtess->ldata, bmtess->totface);
232
233         mesh_update_customdata_pointers(me);
234         
235         /*set indices*/
236         i = 0;
237         BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
238                 VECCOPY(mvert->co, v->co);
239
240                 mvert->no[0] = (unsigned char) (v->no[0]*255.0f);
241                 mvert->no[1] = (unsigned char) (v->no[1]*255.0f);
242                 mvert->no[2] = (unsigned char) (v->no[2]*255.0f);
243                 
244                 mvert->flag = BMFlags_To_MEFlags(v);
245
246                 BMINDEX_SET(v, i);
247
248                 /*copy over customdata*/
249                 CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
250
251                 i++;
252                 mvert++;
253         }
254
255         i = 0;
256         BM_ITER(v, &iter, bmtess, BM_VERTS_OF_MESH, NULL) {
257                 BMINDEX_SET(v, i);
258                 i++;
259         }
260
261         i = 0;
262         BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
263                 medge->v1 = BMINDEX_GET(e->v1);
264                 medge->v2 = BMINDEX_GET(e->v2);
265
266                 medge->flag = BMFlags_To_MEFlags(e);
267
268                 BMINDEX_SET(e, i);
269
270                 /*copy over customdata*/
271                 CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
272
273                 i++;
274                 medge++;
275         }
276         
277         i = 0;
278         BM_ITER(f, &iter, bmtess, BM_FACES_OF_MESH, NULL) {
279                 mface->mat_nr = f->mat_nr;
280                 mface->flag = BMFlags_To_MEFlags(f);
281                 
282                 mface->v1 = BMINDEX_GET(f->loopbase->v);
283                 mface->v2 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next)->v);
284                 if (f->len < 3) { 
285                         mface++;
286                         i++; 
287                         continue;
288                 }
289
290                 mface->v3 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next->next)->v);
291                 if (f->len < 4) { 
292                         mface->v4 = 0;
293                         mface++;
294                         i++; 
295                         continue;
296                 }
297
298                 mface->v4 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next->next->next)->v);
299                 test_index_face(mface, &me->fdata, i, 1);
300                 
301                 BM_loops_to_corners(bmtess, me, i, f, numTex, numCol);
302
303                 mface++;
304                 i++;
305         }
306
307         i = 0;
308         j = 0;
309         BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
310                 mpoly->loopstart = j;
311                 mpoly->totloop = f->len;
312                 mpoly->mat_nr = f->mat_nr;
313                 mpoly->flag = BMFlags_To_MEFlags(f);
314
315                 l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
316                 for ( ; l; l=BMIter_Step(&liter), j++, mloop++) {
317                         mloop->e = BMINDEX_GET(l->e);
318                         mloop->v = BMINDEX_GET(l->v);
319
320                         /*copy over customdata*/
321                         CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
322                 }
323                 
324                 if (f == bm->act_face) me->act_face = i;
325
326                 /*copy over customdata*/
327                 CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
328
329                 i++;
330                 mpoly++;
331         }
332
333         BM_Free_Mesh(bmtess);
334 }