brought weight paint back.
[blender-staging.git] / source / blender / blenkernel / intern / mesh.c
1
2 /*  mesh.c
3  *
4  *  
5  * 
6  * $Id$
7  *
8  * ***** BEGIN GPL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * Contributor(s): Blender Foundation
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 #ifdef HAVE_CONFIG_H
33 #include <config.h>
34 #endif
35
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdio.h>
39 #include <math.h>
40
41 #include "MEM_guardedalloc.h"
42
43 #include "DNA_ID.h"
44 #include "DNA_curve_types.h"
45 #include "DNA_material_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_image_types.h"
48 #include "DNA_key_types.h"
49 #include "DNA_mesh_types.h"
50 #include "DNA_meshdata_types.h"
51 #include "DNA_ipo_types.h"
52
53 #include "BKE_customdata.h"
54 #include "BKE_depsgraph.h"
55 #include "BKE_main.h"
56 #include "BKE_DerivedMesh.h"
57 #include "BKE_global.h"
58 #include "BKE_mesh.h"
59 #include "BKE_subsurf.h"
60 #include "BKE_displist.h"
61 #include "BKE_library.h"
62 #include "BKE_material.h"
63 #include "BKE_key.h"
64 /* these 2 are only used by conversion functions */
65 #include "BKE_curve.h"
66 /* -- */
67 #include "BKE_object.h"
68 #include "BKE_utildefines.h"
69 #include "BKE_tessmesh.h"
70
71 #include "BLI_blenlib.h"
72 #include "BLI_editVert.h"
73 #include "BLI_arithb.h"
74
75 #include "bmesh.h"
76
77 EditMesh *BKE_mesh_get_editmesh(Mesh *me)
78 {
79         return bmesh_to_editmesh(me->edit_btmesh->bm);
80 }
81
82 void BKE_mesh_end_editmesh(Mesh *me, EditMesh *em)
83 {
84         BM_Free_Mesh(me->edit_btmesh->bm);
85         me->edit_btmesh->bm = editmesh_to_bmesh(em);
86         BMEdit_RecalcTesselation(me->edit_btmesh);
87 }
88
89 static void mesh_ensure_tesselation_customdata(Mesh *me)
90 {
91         int tottex, totcol;
92
93         tottex = CustomData_number_of_layers(&me->fdata, CD_MTFACE);
94         totcol = CustomData_number_of_layers(&me->fdata, CD_MCOL);
95         
96         if (tottex != CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY) ||
97             totcol != CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL))
98         {
99                 CustomData_free(&me->fdata, me->totface);
100                 memset(&me->fdata, 0, sizeof(&me->fdata));
101
102                 CustomData_from_bmeshpoly(&me->fdata, &me->pdata, &me->ldata, me->totface);
103                 printf("Warning! Tesselation uvs or vcol data got out of sync, had to reset!\n");
104         }
105 }
106
107 /*this ensures grouped customdata (e.g. mtexpoly and mloopuv and mtface, or
108   mloopcol and mcol) have the same relative active/render/clone/mask indices.*/
109 void mesh_update_linked_customdata(Mesh *me)
110 {
111         int act;
112
113         if (me->edit_btmesh)
114                 BMEdit_UpdateLinkedCustomData(me->edit_btmesh);
115
116         mesh_ensure_tesselation_customdata(me);
117
118         if (CustomData_has_layer(&me->pdata, CD_MTEXPOLY)) {
119                 act = CustomData_get_active_layer(&me->pdata, CD_MTEXPOLY);
120                 CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, act);
121                 CustomData_set_layer_active(&me->fdata, CD_MTFACE, act);
122
123                 act = CustomData_get_render_layer(&me->pdata, CD_MTEXPOLY);
124                 CustomData_set_layer_render(&me->ldata, CD_MLOOPUV, act);
125                 CustomData_set_layer_render(&me->fdata, CD_MTFACE, act);
126
127                 act = CustomData_get_clone_layer(&me->pdata, CD_MTEXPOLY);
128                 CustomData_set_layer_clone(&me->ldata, CD_MLOOPUV, act);
129                 CustomData_set_layer_clone(&me->fdata, CD_MTFACE, act);
130
131                 act = CustomData_get_mask_layer(&me->pdata, CD_MTEXPOLY);
132                 CustomData_set_layer_mask(&me->ldata, CD_MLOOPUV, act);
133                 CustomData_set_layer_mask(&me->fdata, CD_MTFACE, act);
134         }
135
136         if (CustomData_has_layer(&me->ldata, CD_MLOOPCOL)) {
137                 act = CustomData_get_active_layer(&me->ldata, CD_MLOOPCOL);
138                 CustomData_set_layer_active(&me->fdata, CD_MCOL, act);
139
140                 act = CustomData_get_render_layer(&me->ldata, CD_MLOOPCOL);
141                 CustomData_set_layer_render(&me->fdata, CD_MCOL, act);
142
143                 act = CustomData_get_clone_layer(&me->ldata, CD_MLOOPCOL);
144                 CustomData_set_layer_clone(&me->fdata, CD_MCOL, act);
145
146                 act = CustomData_get_mask_layer(&me->ldata, CD_MLOOPCOL);
147                 CustomData_set_layer_mask(&me->fdata, CD_MCOL, act);
148         }
149 }
150
151 void mesh_update_customdata_pointers(Mesh *me)
152 {
153         mesh_update_linked_customdata(me);
154
155         me->mvert = CustomData_get_layer(&me->vdata, CD_MVERT);
156         me->dvert = CustomData_get_layer(&me->vdata, CD_MDEFORMVERT);
157         me->msticky = CustomData_get_layer(&me->vdata, CD_MSTICKY);
158
159         me->medge = CustomData_get_layer(&me->edata, CD_MEDGE);
160
161         me->mface = CustomData_get_layer(&me->fdata, CD_MFACE);
162         me->mcol = CustomData_get_layer(&me->fdata, CD_MCOL);
163         me->mtface = CustomData_get_layer(&me->fdata, CD_MTFACE);
164         
165         me->mpoly = CustomData_get_layer(&me->pdata, CD_MPOLY);
166         me->mloop = CustomData_get_layer(&me->ldata, CD_MLOOP);
167
168         me->mtpoly = CustomData_get_layer(&me->pdata, CD_MTEXPOLY);
169         me->mloopcol = CustomData_get_layer(&me->ldata, CD_MLOOPCOL);
170         me->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
171 }
172
173 /* Note: unlinking is called when me->id.us is 0, question remains how
174  * much unlinking of Library data in Mesh should be done... probably
175  * we need a more generic method, like the expand() functions in
176  * readfile.c */
177
178 void unlink_mesh(Mesh *me)
179 {
180         int a;
181         
182         if(me==0) return;
183         
184         for(a=0; a<me->totcol; a++) {
185                 if(me->mat[a]) me->mat[a]->id.us--;
186                 me->mat[a]= 0;
187         }
188
189         if(me->key) {
190                 me->key->id.us--;
191                 if (me->key->id.us == 0 && me->key->ipo )
192                         me->key->ipo->id.us--;
193         }
194         me->key= 0;
195         
196         if(me->texcomesh) me->texcomesh= 0;
197 }
198
199
200 /* do not free mesh itself */
201 void free_mesh(Mesh *me)
202 {
203         unlink_mesh(me);
204
205         if(me->pv) {
206                 if(me->pv->vert_map) MEM_freeN(me->pv->vert_map);
207                 if(me->pv->edge_map) MEM_freeN(me->pv->edge_map);
208                 if(me->pv->old_faces) MEM_freeN(me->pv->old_faces);
209                 if(me->pv->old_edges) MEM_freeN(me->pv->old_edges);
210                 me->totvert= me->pv->totvert;
211                 me->totedge= me->pv->totedge;
212                 me->totface= me->pv->totface;
213                 MEM_freeN(me->pv);
214         }
215
216         CustomData_free(&me->vdata, me->totvert);
217         CustomData_free(&me->edata, me->totedge);
218         CustomData_free(&me->fdata, me->totface);
219         CustomData_free(&me->ldata, me->totloop);
220         CustomData_free(&me->pdata, me->totpoly);
221
222         if(me->mat) MEM_freeN(me->mat);
223         
224         if(me->bb) MEM_freeN(me->bb);
225         if(me->mselect) MEM_freeN(me->mselect);
226         if(me->edit_btmesh) MEM_freeN(me->edit_btmesh);
227 }
228
229 void copy_dverts(MDeformVert *dst, MDeformVert *src, int copycount)
230 {
231         /* Assumes dst is already set up */
232         int i;
233
234         if (!src || !dst)
235                 return;
236
237         memcpy (dst, src, copycount * sizeof(MDeformVert));
238         
239         for (i=0; i<copycount; i++){
240                 if (src[i].dw){
241                         dst[i].dw = MEM_callocN (sizeof(MDeformWeight)*src[i].totweight, "copy_deformWeight");
242                         memcpy (dst[i].dw, src[i].dw, sizeof (MDeformWeight)*src[i].totweight);
243                 }
244         }
245
246 }
247
248 void free_dverts(MDeformVert *dvert, int totvert)
249 {
250         /* Instead of freeing the verts directly,
251         call this function to delete any special
252         vert data */
253         int     i;
254
255         if (!dvert)
256                 return;
257
258         /* Free any special data from the verts */
259         for (i=0; i<totvert; i++){
260                 if (dvert[i].dw) MEM_freeN (dvert[i].dw);
261         }
262         MEM_freeN (dvert);
263 }
264
265 Mesh *add_mesh(char *name)
266 {
267         Mesh *me;
268         
269         me= alloc_libblock(&G.main->mesh, ID_ME, name);
270         
271         me->size[0]= me->size[1]= me->size[2]= 1.0;
272         me->smoothresh= 30;
273         me->texflag= AUTOSPACE;
274         me->flag= ME_TWOSIDED;
275         me->bb= unit_boundbox();
276         me->drawflag= ME_DRAWEDGES|ME_DRAWFACES|ME_DRAWCREASES;
277         
278         return me;
279 }
280
281 Mesh *copy_mesh(Mesh *me)
282 {
283         Mesh *men;
284         MTFace *tface;
285         MTexPoly *txface;
286         int a, i;
287         
288         men= copy_libblock(me);
289         
290         men->mat= MEM_dupallocN(me->mat);
291         for(a=0; a<men->totcol; a++) {
292                 id_us_plus((ID *)men->mat[a]);
293         }
294         id_us_plus((ID *)men->texcomesh);
295
296         CustomData_copy(&me->vdata, &men->vdata, CD_MASK_MESH, CD_DUPLICATE, men->totvert);
297         CustomData_copy(&me->edata, &men->edata, CD_MASK_MESH, CD_DUPLICATE, men->totedge);
298         CustomData_copy(&me->fdata, &men->fdata, CD_MASK_MESH, CD_DUPLICATE, men->totface);
299         CustomData_copy(&me->ldata, &men->ldata, CD_MASK_MESH, CD_DUPLICATE, men->totloop);
300         CustomData_copy(&me->pdata, &men->pdata, CD_MASK_MESH, CD_DUPLICATE, men->totpoly);
301         mesh_update_customdata_pointers(men);
302
303         /* ensure indirect linked data becomes lib-extern */
304         for(i=0; i<me->fdata.totlayer; i++) {
305                 if(me->fdata.layers[i].type == CD_MTFACE) {
306                         tface= (MTFace*)me->fdata.layers[i].data;
307
308                         for(a=0; a<me->totface; a++, tface++)
309                                 if(tface->tpage)
310                                         id_lib_extern((ID*)tface->tpage);
311                 }
312         }
313
314         for(i=0; i<me->pdata.totlayer; i++) {
315                 if(me->pdata.layers[i].type == CD_MTEXPOLY) {
316                         txface= (MTexPoly*)me->pdata.layers[i].data;
317
318                         for(a=0; a<me->totpoly; a++, txface++)
319                                 if(txface->tpage)
320                                         id_lib_extern((ID*)txface->tpage);
321                 }
322         }
323
324         men->mselect= NULL;
325
326         men->bb= MEM_dupallocN(men->bb);
327         
328         men->key= copy_key(me->key);
329         if(men->key) men->key->from= (ID *)men;
330
331         return men;
332 }
333
334 BMesh *BKE_mesh_to_bmesh(Mesh *me)
335 {
336         BMesh *bm;
337         int allocsize[4] = {512,512,2048,512};
338
339         bm = BM_Make_Mesh(allocsize);
340
341         BMO_CallOpf(bm, "mesh_to_bmesh mesh=%p", me);
342
343         return bm;
344 }
345
346 void make_local_tface(Mesh *me)
347 {
348         MTFace *tface;
349         MTexPoly *txface;
350         Image *ima;
351         int a, i;
352         
353         for(i=0; i<me->pdata.totlayer; i++) {
354                 if(me->pdata.layers[i].type == CD_MTEXPOLY) {
355                         txface= (MTexPoly*)me->fdata.layers[i].data;
356                         
357                         for(a=0; a<me->totpoly; a++, txface++) {
358                                 /* special case: ima always local immediately */
359                                 if(txface->tpage) {
360                                         ima= txface->tpage;
361                                         if(ima->id.lib) {
362                                                 ima->id.lib= 0;
363                                                 ima->id.flag= LIB_LOCAL;
364                                                 new_id(0, (ID *)ima, 0);
365                                         }
366                                 }
367                         }
368                 }
369         }
370
371         for(i=0; i<me->fdata.totlayer; i++) {
372                 if(me->fdata.layers[i].type == CD_MTFACE) {
373                         tface= (MTFace*)me->fdata.layers[i].data;
374                         
375                         for(a=0; a<me->totface; a++, tface++) {
376                                 /* special case: ima always local immediately */
377                                 if(tface->tpage) {
378                                         ima= tface->tpage;
379                                         if(ima->id.lib) {
380                                                 ima->id.lib= 0;
381                                                 ima->id.flag= LIB_LOCAL;
382                                                 new_id(0, (ID *)ima, 0);
383                                         }
384                                 }
385                         }
386                 }
387         }
388
389 }
390
391 void make_local_mesh(Mesh *me)
392 {
393         Object *ob;
394         Mesh *men;
395         int local=0, lib=0;
396
397         /* - only lib users: do nothing
398             * - only local users: set flag
399             * - mixed: make copy
400             */
401         
402         if(me->id.lib==0) return;
403         if(me->id.us==1) {
404                 me->id.lib= 0;
405                 me->id.flag= LIB_LOCAL;
406                 new_id(0, (ID *)me, 0);
407                 
408                 if(me->mtface) make_local_tface(me);
409                 
410                 return;
411         }
412         
413         ob= G.main->object.first;
414         while(ob) {
415                 if( me==get_mesh(ob) ) {
416                         if(ob->id.lib) lib= 1;
417                         else local= 1;
418                 }
419                 ob= ob->id.next;
420         }
421         
422         if(local && lib==0) {
423                 me->id.lib= 0;
424                 me->id.flag= LIB_LOCAL;
425                 new_id(0, (ID *)me, 0);
426                 
427                 if(me->mtface) make_local_tface(me);
428                 
429         }
430         else if(local && lib) {
431                 men= copy_mesh(me);
432                 men->id.us= 0;
433                 
434                 ob= G.main->object.first;
435                 while(ob) {
436                         if( me==get_mesh(ob) ) {                                
437                                 if(ob->id.lib==0) {
438                                         set_mesh(ob, men);
439                                 }
440                         }
441                         ob= ob->id.next;
442                 }
443         }
444 }
445
446 void boundbox_mesh(Mesh *me, float *loc, float *size)
447 {
448         MVert *mvert;
449         BoundBox *bb;
450         float min[3], max[3];
451         float mloc[3], msize[3];
452         int a;
453         
454         if(me->bb==0) me->bb= MEM_callocN(sizeof(BoundBox), "boundbox");
455         bb= me->bb;
456         
457         INIT_MINMAX(min, max);
458
459         if (!loc) loc= mloc;
460         if (!size) size= msize;
461         
462         mvert= me->mvert;
463         for(a=0; a<me->totvert; a++, mvert++) {
464                 DO_MINMAX(mvert->co, min, max);
465         }
466
467         if(!me->totvert) {
468                 min[0] = min[1] = min[2] = -1.0f;
469                 max[0] = max[1] = max[2] = 1.0f;
470         }
471
472         loc[0]= (min[0]+max[0])/2.0f;
473         loc[1]= (min[1]+max[1])/2.0f;
474         loc[2]= (min[2]+max[2])/2.0f;
475                 
476         size[0]= (max[0]-min[0])/2.0f;
477         size[1]= (max[1]-min[1])/2.0f;
478         size[2]= (max[2]-min[2])/2.0f;
479         
480         boundbox_set_from_min_max(bb, min, max);
481 }
482
483 void tex_space_mesh(Mesh *me)
484 {
485         KeyBlock *kb;
486         float *fp, loc[3], size[3], min[3], max[3];
487         int a;
488
489         boundbox_mesh(me, loc, size);
490
491         if(me->texflag & AUTOSPACE) {
492                 if(me->key) {
493                         kb= me->key->refkey;
494                         if (kb) {
495                                 
496                                 INIT_MINMAX(min, max);
497                                 
498                                 fp= kb->data;
499                                 for(a=0; a<kb->totelem; a++, fp+=3) {   
500                                         DO_MINMAX(fp, min, max);
501                                 }
502                                 if(kb->totelem) {
503                                         loc[0]= (min[0]+max[0])/2.0f; loc[1]= (min[1]+max[1])/2.0f; loc[2]= (min[2]+max[2])/2.0f;
504                                         size[0]= (max[0]-min[0])/2.0f; size[1]= (max[1]-min[1])/2.0f; size[2]= (max[2]-min[2])/2.0f;
505                                 }
506                                 else {
507                                         loc[0]= loc[1]= loc[2]= 0.0;
508                                         size[0]= size[1]= size[2]= 0.0;
509                                 }
510                                 
511                         }
512                 }
513
514                 for (a=0; a<3; a++) {
515                         if(size[a]==0.0) size[a]= 1.0;
516                         else if(size[a]>0.0 && size[a]<0.00001) size[a]= 0.00001;
517                         else if(size[a]<0.0 && size[a]> -0.00001) size[a]= -0.00001;
518                 }
519
520                 VECCOPY(me->loc, loc);
521                 VECCOPY(me->size, size);
522                 me->rot[0]= me->rot[1]= me->rot[2]= 0.0;
523         }
524 }
525
526 BoundBox *mesh_get_bb(Object *ob)
527 {
528         Mesh *me= ob->data;
529
530         if(ob->bb)
531                 return ob->bb;
532
533         if (!me->bb)
534                 tex_space_mesh(me);
535
536         return me->bb;
537 }
538
539 void mesh_get_texspace(Mesh *me, float *loc_r, float *rot_r, float *size_r)
540 {
541         if (!me->bb) {
542                 tex_space_mesh(me);
543         }
544
545         if (loc_r) VECCOPY(loc_r, me->loc);
546         if (rot_r) VECCOPY(rot_r, me->rot);
547         if (size_r) VECCOPY(size_r, me->size);
548 }
549
550 float *get_mesh_orco_verts(Object *ob)
551 {
552         Mesh *me = ob->data;
553         int a, totvert;
554         float (*vcos)[3] = NULL;
555
556         /* Get appropriate vertex coordinates */
557         if(me->key && me->texcomesh==0 && me->key->refkey) {
558                 vcos= mesh_getRefKeyCos(me, &totvert);
559         }
560         else {
561                 MVert *mvert = NULL;            
562                 Mesh *tme = me->texcomesh?me->texcomesh:me;
563
564                 vcos = MEM_callocN(sizeof(*vcos)*me->totvert, "orco mesh");
565                 mvert = tme->mvert;
566                 totvert = MIN2(tme->totvert, me->totvert);
567
568                 for(a=0; a<totvert; a++, mvert++) {
569                         vcos[a][0]= mvert->co[0];
570                         vcos[a][1]= mvert->co[1];
571                         vcos[a][2]= mvert->co[2];
572                 }
573         }
574
575         return (float*)vcos;
576 }
577
578 void transform_mesh_orco_verts(Mesh *me, float (*orco)[3], int totvert, int invert)
579 {
580         float loc[3], size[3];
581         int a;
582
583         mesh_get_texspace(me->texcomesh?me->texcomesh:me, loc, NULL, size);
584
585         if(invert) {
586                 for(a=0; a<totvert; a++) {
587                         float *co = orco[a];
588                         co[0] = co[0]*size[0] + loc[0];
589                         co[1] = co[1]*size[1] + loc[1];
590                         co[2] = co[2]*size[2] + loc[2];
591                 }
592         }
593         else {
594                 for(a=0; a<totvert; a++) {
595                         float *co = orco[a];
596                         co[0] = (co[0]-loc[0])/size[0];
597                         co[1] = (co[1]-loc[1])/size[1];
598                         co[2] = (co[2]-loc[2])/size[2];
599                 }
600         }
601 }
602
603 /* rotates the vertices of a face in case v[2] or v[3] (vertex index) is = 0.
604    this is necessary to make the if(mface->v4) check for quads work */
605 int test_index_face(MFace *mface, CustomData *fdata, int mfindex, int nr)
606 {
607         /* first test if the face is legal */
608         if(mface->v3 && mface->v3==mface->v4) {
609                 mface->v4= 0;
610                 nr--;
611         }
612         if(mface->v2 && mface->v2==mface->v3) {
613                 mface->v3= mface->v4;
614                 mface->v4= 0;
615                 nr--;
616         }
617         if(mface->v1==mface->v2) {
618                 mface->v2= mface->v3;
619                 mface->v3= mface->v4;
620                 mface->v4= 0;
621                 nr--;
622         }
623
624         /* prevent a zero at wrong index location */
625         if(nr==3) {
626                 if(mface->v3==0) {
627                         static int corner_indices[4] = {1, 2, 0, 3};
628
629                         SWAP(int, mface->v1, mface->v2);
630                         SWAP(int, mface->v2, mface->v3);
631
632                         if(fdata)
633                                 CustomData_swap(fdata, mfindex, corner_indices);
634                 }
635         }
636         else if(nr==4) {
637                 if(mface->v3==0 || mface->v4==0) {
638                         static int corner_indices[4] = {2, 3, 0, 1};
639
640                         SWAP(int, mface->v1, mface->v3);
641                         SWAP(int, mface->v2, mface->v4);
642
643                         if(fdata)
644                                 CustomData_swap(fdata, mfindex, corner_indices);
645                 }
646         }
647
648         return nr;
649 }
650
651 Mesh *get_mesh(Object *ob)
652 {
653         
654         if(ob==0) return 0;
655         if(ob->type==OB_MESH) return ob->data;
656         else return 0;
657 }
658
659 void set_mesh(Object *ob, Mesh *me)
660 {
661         Mesh *old=0;
662         
663         if(ob==0) return;
664         
665         if(ob->type==OB_MESH) {
666                 old= ob->data;
667                 old->id.us--;
668                 ob->data= me;
669                 id_us_plus((ID *)me);
670         }
671         
672         test_object_materials((ID *)me);
673 }
674
675 /* ************** make edges in a Mesh, for outside of editmode */
676
677 struct edgesort {
678         int v1, v2;
679         short is_loose, is_draw;
680 };
681
682 /* edges have to be added with lowest index first for sorting */
683 static void to_edgesort(struct edgesort *ed, int v1, int v2, short is_loose, short is_draw)
684 {
685         if(v1<v2) {
686                 ed->v1= v1; ed->v2= v2;
687         }
688         else {
689                 ed->v1= v2; ed->v2= v1;
690         }
691         ed->is_loose= is_loose;
692         ed->is_draw= is_draw;
693 }
694
695 static int vergedgesort(const void *v1, const void *v2)
696 {
697         const struct edgesort *x1=v1, *x2=v2;
698
699         if( x1->v1 > x2->v1) return 1;
700         else if( x1->v1 < x2->v1) return -1;
701         else if( x1->v2 > x2->v2) return 1;
702         else if( x1->v2 < x2->v2) return -1;
703         
704         return 0;
705 }
706
707 void make_edges(Mesh *me, int old)
708 {
709         MFace *mface;
710         MEdge *medge;
711         struct edgesort *edsort, *ed;
712         int a, totedge=0, final=0;
713         
714         /* we put all edges in array, sort them, and detect doubles that way */
715         
716         for(a= me->totface, mface= me->mface; a>0; a--, mface++) {
717                 if(mface->v4) totedge+=4;
718                 else if(mface->v3) totedge+=3;
719                 else totedge+=1;
720         }
721         
722         if(totedge==0) {
723                 /* flag that mesh has edges */
724                 me->medge = MEM_callocN(0, "make mesh edges");
725                 me->totedge = 0;
726                 return;
727         }
728         
729         ed= edsort= MEM_mallocN(totedge*sizeof(struct edgesort), "edgesort");
730         
731         for(a= me->totface, mface= me->mface; a>0; a--, mface++) {
732                 to_edgesort(ed++, mface->v1, mface->v2, !mface->v3, mface->edcode & ME_V1V2);
733                 if(mface->v4) {
734                         to_edgesort(ed++, mface->v2, mface->v3, 0, mface->edcode & ME_V2V3);
735                         to_edgesort(ed++, mface->v3, mface->v4, 0, mface->edcode & ME_V3V4);
736                         to_edgesort(ed++, mface->v4, mface->v1, 0, mface->edcode & ME_V4V1);
737                 }
738                 else if(mface->v3) {
739                         to_edgesort(ed++, mface->v2, mface->v3, 0, mface->edcode & ME_V2V3);
740                         to_edgesort(ed++, mface->v3, mface->v1, 0, mface->edcode & ME_V3V1);
741                 }
742         }
743         
744         qsort(edsort, totedge, sizeof(struct edgesort), vergedgesort);
745         
746         /* count final amount */
747         for(a=totedge, ed=edsort; a>1; a--, ed++) {
748                 /* edge is unique when it differs from next edge, or is last */
749                 if(ed->v1 != (ed+1)->v1 || ed->v2 != (ed+1)->v2) final++;
750         }
751         final++;
752         
753
754         medge= CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, final);
755         me->medge= medge;
756         me->totedge= final;
757         
758         for(a=totedge, ed=edsort; a>1; a--, ed++) {
759                 /* edge is unique when it differs from next edge, or is last */
760                 if(ed->v1 != (ed+1)->v1 || ed->v2 != (ed+1)->v2) {
761                         medge->v1= ed->v1;
762                         medge->v2= ed->v2;
763                         if(old==0 || ed->is_draw) medge->flag= ME_EDGEDRAW|ME_EDGERENDER;
764                         if(ed->is_loose) medge->flag|= ME_LOOSEEDGE;
765                         medge++;
766                 }
767                 else {
768                         /* equal edge, we merge the drawflag */
769                         (ed+1)->is_draw |= ed->is_draw;
770                 }
771         }
772         /* last edge */
773         medge->v1= ed->v1;
774         medge->v2= ed->v2;
775         medge->flag= ME_EDGEDRAW;
776         if(ed->is_loose) medge->flag|= ME_LOOSEEDGE;
777         medge->flag |= ME_EDGERENDER;
778
779         MEM_freeN(edsort);
780
781         mesh_strip_loose_faces(me);
782 }
783
784 void mesh_strip_loose_faces(Mesh *me)
785 {
786         int a,b;
787
788         for (a=b=0; a<me->totface; a++) {
789                 if (me->mface[a].v3) {
790                         if (a!=b) {
791                                 memcpy(&me->mface[b],&me->mface[a],sizeof(me->mface[b]));
792                                 CustomData_copy_data(&me->fdata, &me->fdata, a, b, 1);
793                                 CustomData_free_elem(&me->fdata, a, 1);
794                         }
795                         b++;
796                 }
797         }
798         me->totface = b;
799 }
800
801
802 void mball_to_mesh(ListBase *lb, Mesh *me)
803 {
804         DispList *dl;
805         MVert *mvert;
806         MFace *mface;
807         float *nors, *verts;
808         int a, *index;
809         
810         dl= lb->first;
811         if(dl==0) return;
812
813         if(dl->type==DL_INDEX4) {
814                 me->flag= ME_NOPUNOFLIP;
815                 me->totvert= dl->nr;
816                 me->totface= dl->parts;
817                 
818                 mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, dl->nr);
819                 mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, dl->parts);
820                 me->mvert= mvert;
821                 me->mface= mface;
822
823                 a= dl->nr;
824                 nors= dl->nors;
825                 verts= dl->verts;
826                 while(a--) {
827                         VECCOPY(mvert->co, verts);
828                         mvert->no[0]= (short int)(nors[0]*32767.0);
829                         mvert->no[1]= (short int)(nors[1]*32767.0);
830                         mvert->no[2]= (short int)(nors[2]*32767.0);
831                         mvert++;
832                         nors+= 3;
833                         verts+= 3;
834                 }
835                 
836                 a= dl->parts;
837                 index= dl->index;
838                 while(a--) {
839                         mface->v1= index[0];
840                         mface->v2= index[1];
841                         mface->v3= index[2];
842                         mface->v4= index[3];
843                         mface->flag= ME_SMOOTH;
844
845                         test_index_face(mface, NULL, 0, (mface->v3==mface->v4)? 3: 4);
846
847                         mface++;
848                         index+= 4;
849                 }
850
851                 make_edges(me, 0);      // all edges
852         }       
853 }
854
855 /* this may fail replacing ob->data, be sure to check ob->type */
856 void nurbs_to_mesh(Object *ob)
857 {
858         Object *ob1;
859         DispList *dl;
860         Mesh *me;
861         Curve *cu;
862         MVert *mvert;
863         MFace *mface;
864         float *data;
865         int a, b, ofs, vertcount, startvert, totvert=0, totvlak=0;
866         int p1, p2, p3, p4, *index;
867
868         cu= ob->data;
869
870         /* count */
871         dl= cu->disp.first;
872         while(dl) {
873                 if(dl->type==DL_SEGM) {
874                         totvert+= dl->parts*dl->nr;
875                         totvlak+= dl->parts*(dl->nr-1);
876                 }
877                 else if(dl->type==DL_POLY) {
878                         /* cyclic polys are filled. except when 3D */
879                         if(cu->flag & CU_3D) {
880                                 totvert+= dl->parts*dl->nr;
881                                 totvlak+= dl->parts*dl->nr;
882                         }
883                 }
884                 else if(dl->type==DL_SURF) {
885                         totvert+= dl->parts*dl->nr;
886                         totvlak+= (dl->parts-1+((dl->flag & DL_CYCL_V)==2))*(dl->nr-1+(dl->flag & DL_CYCL_U));
887                 }
888                 else if(dl->type==DL_INDEX3) {
889                         totvert+= dl->nr;
890                         totvlak+= dl->parts;
891                 }
892                 dl= dl->next;
893         }
894         if(totvert==0) {
895                 /* error("can't convert"); */
896                 /* Make Sure you check ob->data is a curve */
897                 return;
898         }
899
900         /* make mesh */
901         me= add_mesh("Mesh");
902         me->totvert= totvert;
903         me->totface= totvlak;
904
905         me->totcol= cu->totcol;
906         me->mat= cu->mat;
907         cu->mat= 0;
908         cu->totcol= 0;
909
910         mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
911         mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, me->totface);
912         me->mvert= mvert;
913         me->mface= mface;
914
915         /* verts and faces */
916         vertcount= 0;
917
918         dl= cu->disp.first;
919         while(dl) {
920                 int smooth= dl->rt & CU_SMOOTH ? 1 : 0;
921                 
922                 if(dl->type==DL_SEGM) {
923                         startvert= vertcount;
924                         a= dl->parts*dl->nr;
925                         data= dl->verts;
926                         while(a--) {
927                                 VECCOPY(mvert->co, data);
928                                 data+=3;
929                                 vertcount++;
930                                 mvert++;
931                         }
932
933                         for(a=0; a<dl->parts; a++) {
934                                 ofs= a*dl->nr;
935                                 for(b=1; b<dl->nr; b++) {
936                                         mface->v1= startvert+ofs+b-1;
937                                         mface->v2= startvert+ofs+b;
938                                         if(smooth) mface->flag |= ME_SMOOTH;
939                                         mface++;
940                                 }
941                         }
942
943                 }
944                 else if(dl->type==DL_POLY) {
945                         /* 3d polys are not filled */
946                         if(cu->flag & CU_3D) {
947                                 startvert= vertcount;
948                                 a= dl->parts*dl->nr;
949                                 data= dl->verts;
950                                 while(a--) {
951                                         VECCOPY(mvert->co, data);
952                                         data+=3;
953                                         vertcount++;
954                                         mvert++;
955                                 }
956         
957                                 for(a=0; a<dl->parts; a++) {
958                                         ofs= a*dl->nr;
959                                         for(b=0; b<dl->nr; b++) {
960                                                 mface->v1= startvert+ofs+b;
961                                                 if(b==dl->nr-1) mface->v2= startvert+ofs;
962                                                 else mface->v2= startvert+ofs+b+1;
963                                                 if(smooth) mface->flag |= ME_SMOOTH;
964                                                 mface++;
965                                         }
966                                 }
967                         }
968                 }
969                 else if(dl->type==DL_INDEX3) {
970                         startvert= vertcount;
971                         a= dl->nr;
972                         data= dl->verts;
973                         while(a--) {
974                                 VECCOPY(mvert->co, data);
975                                 data+=3;
976                                 vertcount++;
977                                 mvert++;
978                         }
979
980                         a= dl->parts;
981                         index= dl->index;
982                         while(a--) {
983                                 mface->v1= startvert+index[0];
984                                 mface->v2= startvert+index[2];
985                                 mface->v3= startvert+index[1];
986                                 mface->v4= 0;
987                                 test_index_face(mface, NULL, 0, 3);
988                                 
989                                 if(smooth) mface->flag |= ME_SMOOTH;
990                                 mface++;
991                                 index+= 3;
992                         }
993         
994         
995                 }
996                 else if(dl->type==DL_SURF) {
997                         startvert= vertcount;
998                         a= dl->parts*dl->nr;
999                         data= dl->verts;
1000                         while(a--) {
1001                                 VECCOPY(mvert->co, data);
1002                                 data+=3;
1003                                 vertcount++;
1004                                 mvert++;
1005                         }
1006
1007                         for(a=0; a<dl->parts; a++) {
1008
1009                                 if( (dl->flag & DL_CYCL_V)==0 && a==dl->parts-1) break;
1010
1011                                 if(dl->flag & DL_CYCL_U) {                      /* p2 -> p1 -> */
1012                                         p1= startvert+ dl->nr*a;        /* p4 -> p3 -> */
1013                                         p2= p1+ dl->nr-1;               /* -----> next row */
1014                                         p3= p1+ dl->nr;
1015                                         p4= p2+ dl->nr;
1016                                         b= 0;
1017                                 }
1018                                 else {
1019                                         p2= startvert+ dl->nr*a;
1020                                         p1= p2+1;
1021                                         p4= p2+ dl->nr;
1022                                         p3= p1+ dl->nr;
1023                                         b= 1;
1024                                 }
1025                                 if( (dl->flag & DL_CYCL_V) && a==dl->parts-1) {
1026                                         p3-= dl->parts*dl->nr;
1027                                         p4-= dl->parts*dl->nr;
1028                                 }
1029
1030                                 for(; b<dl->nr; b++) {
1031                                         mface->v1= p1;
1032                                         mface->v2= p3;
1033                                         mface->v3= p4;
1034                                         mface->v4= p2;
1035                                         mface->mat_nr= (unsigned char)dl->col;
1036                                         test_index_face(mface, NULL, 0, 4);
1037                                         
1038                                         if(smooth) mface->flag |= ME_SMOOTH;
1039                                         mface++;
1040
1041                                         p4= p3; 
1042                                         p3++;
1043                                         p2= p1; 
1044                                         p1++;
1045                                 }
1046                         }
1047
1048                 }
1049
1050                 dl= dl->next;
1051         }
1052
1053         make_edges(me, 0);      // all edges
1054         mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
1055
1056         if(ob->data) {
1057                 free_libblock(&G.main->curve, ob->data);
1058         }
1059         ob->data= me;
1060         ob->type= OB_MESH;
1061         
1062         /* other users */
1063         ob1= G.main->object.first;
1064         while(ob1) {
1065                 if(ob1->data==cu) {
1066                         ob1->type= OB_MESH;
1067                 
1068                         ob1->data= ob->data;
1069                         id_us_plus((ID *)ob->data);
1070                 }
1071                 ob1= ob1->id.next;
1072         }
1073
1074 }
1075
1076 void mesh_delete_material_index(Mesh *me, int index)
1077 {
1078         int i;
1079
1080         for (i=0; i<me->totface; i++) {
1081                 MFace *mf = &((MFace*) me->mface)[i];
1082                 if (mf->mat_nr && mf->mat_nr>=index) 
1083                         mf->mat_nr--;
1084         }
1085 }
1086
1087 void mesh_set_smooth_flag(Object *meshOb, int enableSmooth) 
1088 {
1089         Mesh *me = meshOb->data;
1090         int i;
1091
1092         for (i=0; i<me->totface; i++) {
1093                 MFace *mf = &((MFace*) me->mface)[i];
1094
1095                 if (enableSmooth) {
1096                         mf->flag |= ME_SMOOTH;
1097                 } else {
1098                         mf->flag &= ~ME_SMOOTH;
1099                 }
1100         }
1101
1102 // XXX do this in caller        DAG_object_flush_update(scene, meshOb, OB_RECALC_DATA);
1103 }
1104
1105 void mesh_calc_normals(MVert *mverts, int numVerts, MFace *mfaces, int numFaces, float **faceNors_r) 
1106 {
1107         float (*tnorms)[3]= MEM_callocN(numVerts*sizeof(*tnorms), "tnorms");
1108         float *fnors= MEM_mallocN(sizeof(*fnors)*3*numFaces, "meshnormals");
1109         int i;
1110
1111         for (i=0; i<numFaces; i++) {
1112                 MFace *mf= &mfaces[i];
1113                 float *f_no= &fnors[i*3];
1114
1115                 if (mf->v4)
1116                         CalcNormFloat4(mverts[mf->v1].co, mverts[mf->v2].co, mverts[mf->v3].co, mverts[mf->v4].co, f_no);
1117                 else
1118                         CalcNormFloat(mverts[mf->v1].co, mverts[mf->v2].co, mverts[mf->v3].co, f_no);
1119                 
1120                 VecAddf(tnorms[mf->v1], tnorms[mf->v1], f_no);
1121                 VecAddf(tnorms[mf->v2], tnorms[mf->v2], f_no);
1122                 VecAddf(tnorms[mf->v3], tnorms[mf->v3], f_no);
1123                 if (mf->v4)
1124                         VecAddf(tnorms[mf->v4], tnorms[mf->v4], f_no);
1125         }
1126         for (i=0; i<numVerts; i++) {
1127                 MVert *mv= &mverts[i];
1128                 float *no= tnorms[i];
1129                 
1130                 if (Normalize(no)==0.0) {
1131                         VECCOPY(no, mv->co);
1132                         Normalize(no);
1133                 }
1134
1135                 mv->no[0]= (short)(no[0]*32767.0);
1136                 mv->no[1]= (short)(no[1]*32767.0);
1137                 mv->no[2]= (short)(no[2]*32767.0);
1138         }
1139         
1140         MEM_freeN(tnorms);
1141
1142         if (faceNors_r) {
1143                 *faceNors_r = fnors;
1144         } else {
1145                 MEM_freeN(fnors);
1146         }
1147 }
1148
1149 float (*mesh_getVertexCos(Mesh *me, int *numVerts_r))[3]
1150 {
1151         int i, numVerts = me->totvert;
1152         float (*cos)[3] = MEM_mallocN(sizeof(*cos)*numVerts, "vertexcos1");
1153         
1154         if (numVerts_r) *numVerts_r = numVerts;
1155         for (i=0; i<numVerts; i++)
1156                 VECCOPY(cos[i], me->mvert[i].co);
1157         
1158         return cos;
1159 }
1160
1161 float (*mesh_getRefKeyCos(Mesh *me, int *numVerts_r))[3]
1162 {
1163         KeyBlock *kb;
1164         float (*cos)[3] = NULL;
1165         int totvert;
1166         
1167         if(me->key && me->key->refkey) {
1168                 if(numVerts_r) *numVerts_r= me->totvert;
1169                 
1170                 kb= me->key->refkey;
1171                 
1172                 /* prevent accessing invalid memory */
1173                 if (me->totvert > kb->totelem)          cos= MEM_callocN(sizeof(*cos)*me->totvert, "vertexcos1");
1174                 else                                                            cos= MEM_mallocN(sizeof(*cos)*me->totvert, "vertexcos1");
1175                 
1176                 totvert= MIN2(kb->totelem, me->totvert);
1177
1178                 memcpy(cos, kb->data, sizeof(*cos)*totvert);
1179         }
1180
1181         return cos;
1182 }
1183
1184 UvVertMap *make_uv_vert_map(struct MFace *mface, struct MTFace *tface, unsigned int totface, unsigned int totvert, int selected, float *limit)
1185 {
1186         UvVertMap *vmap;
1187         UvMapVert *buf;
1188         MFace *mf;
1189         MTFace *tf;
1190         unsigned int a;
1191         int     i, totuv, nverts;
1192
1193         totuv = 0;
1194
1195         /* generate UvMapVert array */
1196         mf= mface;
1197         tf= tface;
1198         for(a=0; a<totface; a++, mf++, tf++)
1199                 if(!selected || (!(mf->flag & ME_HIDE) && (mf->flag & ME_FACE_SEL)))
1200                         totuv += (mf->v4)? 4: 3;
1201                 
1202         if(totuv==0)
1203                 return NULL;
1204         
1205         vmap= (UvVertMap*)MEM_callocN(sizeof(*vmap), "UvVertMap");
1206         if (!vmap)
1207                 return NULL;
1208
1209         vmap->vert= (UvMapVert**)MEM_callocN(sizeof(*vmap->vert)*totvert, "UvMapVert*");
1210         buf= vmap->buf= (UvMapVert*)MEM_callocN(sizeof(*vmap->buf)*totuv, "UvMapVert");
1211
1212         if (!vmap->vert || !vmap->buf) {
1213                 free_uv_vert_map(vmap);
1214                 return NULL;
1215         }
1216
1217         mf= mface;
1218         tf= tface;
1219         for(a=0; a<totface; a++, mf++, tf++) {
1220                 if(!selected || (!(mf->flag & ME_HIDE) && (mf->flag & ME_FACE_SEL))) {
1221                         nverts= (mf->v4)? 4: 3;
1222
1223                         for(i=0; i<nverts; i++) {
1224                                 buf->tfindex= i;
1225                                 buf->f= a;
1226                                 buf->separate = 0;
1227                                 buf->next= vmap->vert[*(&mf->v1 + i)];
1228                                 vmap->vert[*(&mf->v1 + i)]= buf;
1229                                 buf++;
1230                         }
1231                 }
1232         }
1233         
1234         /* sort individual uvs for each vert */
1235         tf= tface;
1236         for(a=0; a<totvert; a++) {
1237                 UvMapVert *newvlist= NULL, *vlist=vmap->vert[a];
1238                 UvMapVert *iterv, *v, *lastv, *next;
1239                 float *uv, *uv2, uvdiff[2];
1240
1241                 while(vlist) {
1242                         v= vlist;
1243                         vlist= vlist->next;
1244                         v->next= newvlist;
1245                         newvlist= v;
1246
1247                         uv= (tf+v->f)->uv[v->tfindex];
1248                         lastv= NULL;
1249                         iterv= vlist;
1250
1251                         while(iterv) {
1252                                 next= iterv->next;
1253
1254                                 uv2= (tf+iterv->f)->uv[iterv->tfindex];
1255                                 Vec2Subf(uvdiff, uv2, uv);
1256
1257
1258                                 if(fabs(uv[0]-uv2[0]) < limit[0] && fabs(uv[1]-uv2[1]) < limit[1]) {
1259                                         if(lastv) lastv->next= next;
1260                                         else vlist= next;
1261                                         iterv->next= newvlist;
1262                                         newvlist= iterv;
1263                                 }
1264                                 else
1265                                         lastv=iterv;
1266
1267                                 iterv= next;
1268                         }
1269
1270                         newvlist->separate = 1;
1271                 }
1272
1273                 vmap->vert[a]= newvlist;
1274         }
1275         
1276         return vmap;
1277 }
1278
1279 UvMapVert *get_uv_map_vert(UvVertMap *vmap, unsigned int v)
1280 {
1281         return vmap->vert[v];
1282 }
1283
1284 void free_uv_vert_map(UvVertMap *vmap)
1285 {
1286         if (vmap) {
1287                 if (vmap->vert) MEM_freeN(vmap->vert);
1288                 if (vmap->buf) MEM_freeN(vmap->buf);
1289                 MEM_freeN(vmap);
1290         }
1291 }
1292
1293 /* Generates a map where the key is the vertex and the value is a list
1294    of faces that use that vertex as a corner. The lists are allocated
1295    from one memory pool. */
1296 void create_vert_face_map(ListBase **map, IndexNode **mem, const MFace *mface, const int totvert, const int totface)
1297 {
1298         int i,j;
1299         IndexNode *node = NULL;
1300         
1301         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert face map");
1302         (*mem) = MEM_callocN(sizeof(IndexNode) * totface*4, "vert face map mem");
1303         node = *mem;
1304         
1305         /* Find the users */
1306         for(i = 0; i < totface; ++i){
1307                 for(j = 0; j < (mface[i].v4?4:3); ++j, ++node) {
1308                         node->index = i;
1309                         BLI_addtail(&(*map)[((unsigned int*)(&mface[i]))[j]], node);
1310                 }
1311         }
1312 }
1313
1314 /* Generates a map where the key is the vertex and the value is a list
1315    of edges that use that vertex as an endpoint. The lists are allocated
1316    from one memory pool. */
1317 void create_vert_edge_map(ListBase **map, IndexNode **mem, const MEdge *medge, const int totvert, const int totedge)
1318 {
1319         int i, j;
1320         IndexNode *node = NULL;
1321  
1322         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert edge map");
1323         (*mem) = MEM_callocN(sizeof(IndexNode) * totedge * 2, "vert edge map mem");
1324         node = *mem;
1325        
1326         /* Find the users */
1327         for(i = 0; i < totedge; ++i){
1328                 for(j = 0; j < 2; ++j, ++node) {
1329                         node->index = i;
1330                         BLI_addtail(&(*map)[((unsigned int*)(&medge[i].v1))[j]], node);
1331                 }
1332         }
1333 }
1334
1335 /* Partial Mesh Visibility */
1336 PartialVisibility *mesh_pmv_copy(PartialVisibility *pmv)
1337 {
1338         PartialVisibility *n= MEM_dupallocN(pmv);
1339         n->vert_map= MEM_dupallocN(pmv->vert_map);
1340         n->edge_map= MEM_dupallocN(pmv->edge_map);
1341         n->old_edges= MEM_dupallocN(pmv->old_edges);
1342         n->old_faces= MEM_dupallocN(pmv->old_faces);
1343         return n;
1344 }
1345
1346 void mesh_pmv_free(PartialVisibility *pv)
1347 {
1348         MEM_freeN(pv->vert_map);
1349         MEM_freeN(pv->edge_map);
1350         MEM_freeN(pv->old_faces);
1351         MEM_freeN(pv->old_edges);
1352         MEM_freeN(pv);
1353 }
1354
1355 void mesh_pmv_revert(Object *ob, Mesh *me)
1356 {
1357         if(me->pv) {
1358                 unsigned i;
1359                 MVert *nve, *old_verts;
1360                 
1361                 /* Reorder vertices */
1362                 nve= me->mvert;
1363                 old_verts = MEM_mallocN(sizeof(MVert)*me->pv->totvert,"PMV revert verts");
1364                 for(i=0; i<me->pv->totvert; ++i)
1365                         old_verts[i]= nve[me->pv->vert_map[i]];
1366
1367                 /* Restore verts, edges and faces */
1368                 CustomData_free_layer_active(&me->vdata, CD_MVERT, me->totvert);
1369                 CustomData_free_layer_active(&me->edata, CD_MEDGE, me->totedge);
1370                 CustomData_free_layer_active(&me->fdata, CD_MFACE, me->totface);
1371
1372                 CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, old_verts, me->pv->totvert);
1373                 CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, me->pv->old_edges, me->pv->totedge);
1374                 CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN, me->pv->old_faces, me->pv->totface);
1375                 mesh_update_customdata_pointers(me);
1376
1377                 me->totvert= me->pv->totvert;
1378                 me->totedge= me->pv->totedge;
1379                 me->totface= me->pv->totface;
1380
1381                 me->pv->old_edges= NULL;
1382                 me->pv->old_faces= NULL;
1383
1384                 /* Free maps */
1385                 MEM_freeN(me->pv->edge_map);
1386                 me->pv->edge_map= NULL;
1387                 MEM_freeN(me->pv->vert_map);
1388                 me->pv->vert_map= NULL;
1389
1390 // XXX do this in caller                DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
1391         }
1392 }
1393
1394 void mesh_pmv_off(Object *ob, Mesh *me)
1395 {
1396         if(ob && me->pv) {
1397                 mesh_pmv_revert(ob, me);
1398                 MEM_freeN(me->pv);
1399                 me->pv= NULL;
1400         }
1401 }
1402
1403 static void mesh_loops_to_corners(CustomData *fdata, CustomData *ldata, 
1404                            CustomData *pdata, int lindex[3], int findex, 
1405                            int polyindex, int numTex, int numCol) 
1406 {
1407         MTFace *texface;
1408         MTexPoly *texpoly;
1409         MCol *mcol;
1410         MLoopCol *mloopcol;
1411         MLoopUV *mloopuv;
1412         int i, j, hasWCol = CustomData_has_layer(ldata, CD_WEIGHT_MLOOPCOL);
1413
1414         for(i=0; i < numTex; i++){
1415                 texface = CustomData_get_n(fdata, CD_MTFACE, findex, i);
1416                 texpoly = CustomData_get_n(pdata, CD_MTEXPOLY, polyindex, i);
1417                 
1418                 texface->tpage = texpoly->tpage;
1419                 texface->flag = texpoly->flag;
1420                 texface->transp = texpoly->transp;
1421                 texface->mode = texpoly->mode;
1422                 texface->tile = texpoly->tile;
1423                 texface->unwrap = texpoly->unwrap;
1424
1425                 for (j=0; j<3; j++) {
1426                         mloopuv = CustomData_get_n(ldata, CD_MLOOPUV, lindex[j], i);
1427                         texface->uv[j][0] = mloopuv->uv[0];
1428                         texface->uv[j][1] = mloopuv->uv[1];
1429                 }
1430         }
1431
1432         for(i=0; i < numCol; i++){
1433                 mcol = CustomData_get_n(fdata, CD_MCOL, findex, i);
1434
1435                 for (j=0; j<3; j++) {
1436                         mloopcol = CustomData_get_n(ldata, CD_MLOOPCOL, lindex[j], i);
1437                         mcol[j].r = mloopcol->r;
1438                         mcol[j].g = mloopcol->g;
1439                         mcol[j].b = mloopcol->b;
1440                         mcol[j].a = mloopcol->a;
1441                 }
1442         }
1443
1444         if (hasWCol) {
1445                 mcol = CustomData_get(fdata,  findex, CD_WEIGHT_MCOL);
1446
1447                 for (j=0; j<3; j++) {
1448                         mloopcol = CustomData_get(ldata, lindex[j], CD_WEIGHT_MLOOPCOL);
1449                         mcol[j].r = mloopcol->r;
1450                         mcol[j].g = mloopcol->g;
1451                         mcol[j].b = mloopcol->b;
1452                         mcol[j].a = mloopcol->a;
1453                 }
1454         }
1455 }
1456
1457 /*this function recreates a tesselation.
1458
1459   returns number of tesselation faces.*/
1460 int mesh_recalcTesselation(CustomData *fdata, 
1461                                    CustomData *ldata, CustomData *pdata,
1462                                    MVert *mvert, int totface, int totloop, 
1463                                    int totpoly)
1464 {
1465         MPoly *mp, *mpoly;
1466         MLoop *ml, *mloop;
1467         MFace *mf = NULL, *mface;
1468         V_DECLARE(mf);
1469         EditVert *v, *lastv, *firstv;
1470         EditFace *f;
1471         V_DECLARE(origIndex);
1472         int i, j, k, lindex[3], *origIndex = NULL, *polyorigIndex;
1473         int numTex, numCol;
1474
1475         mpoly = CustomData_get_layer(pdata, CD_MPOLY);
1476         mloop = CustomData_get_layer(ldata, CD_MLOOP);
1477
1478         numTex = CustomData_number_of_layers(ldata, CD_MLOOPUV);
1479         numCol = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
1480         
1481         k = 0;
1482         mp = mpoly;
1483         polyorigIndex = CustomData_get_layer(pdata, CD_ORIGINDEX);
1484         for (i=0; i<totpoly; i++, mp++) {
1485                 ml = mloop + mp->loopstart;
1486                 firstv = NULL;
1487                 lastv = NULL;
1488                 for (j=0; j<mp->totloop; j++, ml++) {
1489                         v = BLI_addfillvert(mvert[ml->v].co);
1490                         if (polyorigIndex)
1491                                 v->tmp.l = polyorigIndex[i];
1492                         else
1493                                 v->tmp.l = i;
1494
1495                         v->keyindex = mp->loopstart + j;
1496
1497                         if (lastv)
1498                                 BLI_addfilledge(lastv, v);
1499
1500                         if (!firstv)
1501                                 firstv = v;
1502                         lastv = v;
1503                 }
1504                 BLI_addfilledge(lastv, firstv);
1505                 
1506                 BLI_edgefill(0, 0);
1507                 for (f=fillfacebase.first; f; f=f->next) {
1508                         V_GROW(mf);
1509                         V_GROW(origIndex);
1510
1511                         /*these are loop indices, they'll be transformed
1512                           into vert indices later.*/
1513                         mf[k].v1 = f->v1->keyindex;
1514                         mf[k].v2 = f->v2->keyindex;
1515                         mf[k].v3 = f->v3->keyindex;
1516                         origIndex[k] = f->v1->tmp.l;
1517
1518                         k++;
1519                 }
1520
1521                 BLI_end_edgefill();
1522         }
1523
1524         CustomData_free(fdata, totface);
1525         memset(fdata, 0, sizeof(CustomData));
1526         totface = k;
1527         
1528         CustomData_add_layer(fdata, CD_MFACE, CD_ASSIGN, mf, totface);
1529         CustomData_add_layer(fdata, CD_ORIGINDEX, CD_ASSIGN, origIndex, totface);
1530         CustomData_from_bmeshpoly(fdata, pdata, ldata, totface);
1531
1532         mface = mf;
1533         for (i=0; i<totface; i++, mf++) {
1534                 /*ensure winding is correct*/
1535                 if (mf->v1 > mf->v2) {
1536                         SWAP(int, mf->v1, mf->v2);
1537                 }
1538                 if (mf->v2 > mf->v3) {
1539                         SWAP(int, mf->v2, mf->v3);
1540                 }
1541                 if (mf->v1 > mf->v2) {
1542                         SWAP(int, mf->v1, mf->v2);
1543                 }
1544
1545                 lindex[0] = mf->v1;
1546                 lindex[1] = mf->v2;
1547                 lindex[2] = mf->v3;
1548
1549                 /*transform loop indices to vert indices*/
1550                 mf->v1 = mloop[mf->v1].v;
1551                 mf->v2 = mloop[mf->v2].v;
1552                 mf->v3 = mloop[mf->v3].v;
1553
1554                 mf->flag = mpoly[origIndex[i]].flag;
1555                 mf->mat_nr = mpoly[origIndex[i]].mat_nr;
1556
1557                 mesh_loops_to_corners(fdata, ldata, pdata,
1558                         lindex, i, origIndex[i], numTex, numCol);
1559         }
1560
1561         return totface;
1562 }