pre-merge commit. the mirror modifier is currently in pieces, to be picked back...
[blender.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, 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(&bm->vdata, &me->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
57         CustomData_copy(&bm->edata, &me->edata, CD_MASK_BMESH, CD_CALLOC, 0);
58         CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
59         CustomData_copy(&bm->pdata, &me->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         for (i=0; i<me->totpoly; i++, mpoly++) {
106                 BMVert *v1, *v2;
107
108                 V_RESET(fedges);
109                 for (j=0; j<mpoly->totloop; j++) {
110                         ml = &me->mloop[mpoly->loopstart+j];
111                         v = vt[ml->v];
112                         e = et[ml->e];
113
114                         V_GROW(fedges);
115
116                         fedges[j] = e;
117                 }
118                 
119                 v1 = vt[me->mloop[mpoly->loopstart].v];
120                 v2 = vt[me->mloop[mpoly->loopstart+1].v];
121
122                 if (v1 == fedges[0]->v1) v2 = fedges[0]->v2;
123                 else {
124                         v1 = fedges[0]->v2;
125                         v2 = fedges[0]->v1;
126                 }
127
128                 f = BM_Make_Ngon(bm, v1, v2, fedges, mpoly->totloop, 0);
129                 
130                 f->head.flag = MEFlags_To_BMFlags(mpoly->flag, BM_FACE);
131                 if (i == me->act_face) bm->act_face = f;
132
133                 /*Copy Custom Data*/
134                 CustomData_to_bmesh_block(&me->fdata, &bm->pdata, i, &f->head.data);
135         }
136 }
137
138 void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) {
139         BMesh *bmtess;
140         Object *ob = BMO_Get_Pnt(op, "object");
141         Scene *scene = BMO_Get_Pnt(op, "scene");
142         Mesh *me = ob->data;
143         MLoop *mloop;
144         MPoly *mpoly;
145         MVert *mvert, *oldverts;
146         MEdge *medge;
147         MFace *mface;
148         BMVert *v;
149         BMEdge *e;
150         BMLoop *l;
151         BMFace *f;
152         BMIter iter, liter;
153         int i, j, ototvert, totloop, numTex, numCol;
154         
155         numTex = CustomData_number_of_layers(&me->pdata, CD_MLOOPUV);
156         numCol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
157
158         bmtess = BM_Copy_Mesh(bm);
159         BMO_CallOpf(bmtess, "makefgon trifan=%i", 0);
160         
161         /* new Vertex block */
162         if(bm->totvert==0) mvert= NULL;
163         else mvert= MEM_callocN(bm->totvert*sizeof(MVert), "loadeditbMesh vert");
164
165         /* new Edge block */
166         if(bm->totedge==0) medge= NULL;
167         else medge= MEM_callocN(bm->totedge*sizeof(MEdge), "loadeditbMesh edge");
168         
169         /* new Face block */
170         if(bmtess->totface==0) mface= NULL;
171         else mface= MEM_callocN(bmtess->totface*sizeof(MFace), "loadeditbMesh face");
172
173         /*build ngon data*/
174         /* new Ngon Face block */
175         if(bm->totface==0) mpoly = NULL;
176         else mpoly= MEM_callocN(bm->totface*sizeof(MPoly), "loadeditbMesh poly");
177         
178         /*find number of loops to allocate*/
179         totloop = 0;
180         BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
181                 totloop += f->len;
182         }
183
184         if (totloop==0) mloop = NULL;
185         else mloop = MEM_callocN(totloop*sizeof(MLoop), "loadeditbMesh loop");
186
187         /* lets save the old verts just in case we are actually working on
188          * a key ... we now do processing of the keys at the end */
189         oldverts= me->mvert;
190
191         /* don't free this yet */
192         CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
193
194         /* free custom data */
195         CustomData_free(&me->vdata, me->totvert);
196         CustomData_free(&me->edata, me->totedge);
197         CustomData_free(&me->fdata, me->totface);
198         CustomData_free(&me->ldata, me->totloop);
199         CustomData_free(&me->pdata, me->totpoly);
200
201         /* add new custom data */
202         me->totvert= bm->totvert;
203         me->totedge= bm->totedge;
204         me->totface= bmtess->totface;
205         me->totloop= totloop;
206         me->totpoly= bm->totface;
207
208         CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
209         CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
210         CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
211         CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
212
213         CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
214         CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
215         CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN, mface, me->totface);
216         CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
217         CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
218
219         CustomData_from_bmeshpoly(&me->fdata, &bmtess->pdata, &bmtess->ldata, bmtess->totface);
220
221         mesh_update_customdata_pointers(me);
222         
223         /*set indices*/
224         i = 0;
225         BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
226                 VECCOPY(mvert->co, v->co);
227
228                 mvert->no[0] = (unsigned char) (v->no[0]*255.0f);
229                 mvert->no[1] = (unsigned char) (v->no[1]*255.0f);
230                 mvert->no[2] = (unsigned char) (v->no[2]*255.0f);
231                 
232                 mvert->flag = BMFlags_To_MEFlags(v);
233
234                 BMINDEX_SET(v, i);
235                 i++;
236                 mvert++;
237         }
238
239         i = 0;
240         BM_ITER(v, &iter, bmtess, BM_VERTS_OF_MESH, NULL) {
241                 BMINDEX_SET(v, i);
242                 i++;
243         }
244
245         i = 0;
246         BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
247                 medge->v1 = BMINDEX_GET(e->v1);
248                 medge->v2 = BMINDEX_GET(e->v2);
249
250                 medge->flag = BMFlags_To_MEFlags(e);
251
252                 BMINDEX_SET(e, i);
253                 i++;
254                 medge++;
255         }
256         
257         i = 0;
258         BM_ITER(f, &iter, bmtess, BM_FACES_OF_MESH, NULL) {
259                 mface->mat_nr = f->mat_nr;
260                 mface->flag = BMFlags_To_MEFlags(f);
261                 
262                 mface->v1 = BMINDEX_GET(f->loopbase->v);
263                 mface->v2 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next)->v);
264                 if (f->len < 3) { 
265                         mface++;
266                         i++; 
267                         continue;
268                 }
269
270                 mface->v3 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next->next)->v);
271                 if (f->len < 4) { 
272                         mface->v4 = 0;
273                         mface++;
274                         i++; 
275                         continue;
276                 }
277
278                 mface->v4 = BMINDEX_GET(((BMLoop*)f->loopbase->head.next->next->next)->v);
279                 test_index_face(mface, &me->fdata, i, 1);
280                 
281                 BM_loops_to_corners(bmtess, me, i, f, numTex, numCol);
282
283                 mface++;
284                 i++;
285         }
286
287         i = 0;
288         j = 0;
289         BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
290                 mpoly->loopstart = j;
291                 mpoly->totloop = f->len;
292                 mpoly->mat_nr = f->mat_nr;
293                 mpoly->flag = BMFlags_To_MEFlags(f);
294
295                 l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
296                 for ( ; l; l=BMIter_Step(&liter), j++, mloop++) {
297                         mloop->e = BMINDEX_GET(l->e);
298                         mloop->v = BMINDEX_GET(l->v);
299                 }
300                 
301                 if (f == bm->act_face) me->act_face = i;
302
303                 i++;
304                 mpoly++;
305         }
306
307         BM_Free_Mesh(bmtess);
308 }