← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/mesh.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenkernel/intern/mesh.c
3
3
 *
4
4
 *  
5
5
 * 
6
 
 * $Id: mesh.c,v 1.14 2004/03/22 22:01:21 jesterking Exp $
 
6
 * $Id: mesh.c,v 1.25 2005/04/04 12:22:33 zuster Exp $
7
7
 *
8
8
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
9
9
 *
38
38
#include <config.h>
39
39
#endif
40
40
 
41
 
#ifdef WIN32
42
 
#include "BLI_winstuff.h"
43
 
#endif
44
 
 
45
41
#include <stdlib.h>
46
42
#include <string.h>
47
43
#include <stdio.h>
59
55
#include "DNA_meshdata_types.h"
60
56
 
61
57
#include "BKE_main.h"
 
58
#include "BKE_DerivedMesh.h"
62
59
#include "BKE_global.h"
63
60
#include "BKE_mesh.h"
64
61
#include "BKE_subsurf.h"
118
115
        return inc;
119
116
}
120
117
 
121
 
float get_mvert_weight (Object *ob, int vert, int defgroup)
122
 
{
123
 
        int     i;
124
 
        Mesh *me;
125
 
        float   result;
126
 
 
127
 
        me=ob->data;
128
 
 
129
 
        if (!me->dvert)
130
 
                return 0.0F;
131
 
 
132
 
        result=0.0F;
133
 
 
134
 
        for (i=0; i<me->dvert[vert].totweight; i++){
135
 
                if (me->dvert[vert].dw[i].def_nr==defgroup)
136
 
                        result+=me->dvert[vert].dw[i].weight;           
137
 
        }
138
 
 
139
 
        return result;
140
 
}
141
 
 
142
118
void unlink_mesh(Mesh *me)
143
119
{
144
120
        int a;
162
138
 
163
139
        unlink_mesh(me);
164
140
 
165
 
        if(me->mat) MEM_freeN(me->mat);
166
 
        if(me->orco) MEM_freeN(me->orco);
 
141
        if(me->mvert) MEM_freeN(me->mvert);
 
142
        if(me->medge) MEM_freeN(me->medge);
167
143
        if(me->mface) MEM_freeN(me->mface);
 
144
        
168
145
        if(me->tface) MEM_freeN(me->tface);
169
 
        if(me->mvert) MEM_freeN(me->mvert);
170
146
        if(me->dvert) free_dverts(me->dvert, me->totvert);
171
147
        if(me->mcol) MEM_freeN(me->mcol);
172
148
        if(me->msticky) MEM_freeN(me->msticky);
 
149
 
 
150
        if(me->mat) MEM_freeN(me->mat);
 
151
        if(me->orco) MEM_freeN(me->orco);
 
152
 
173
153
        if(me->bb) MEM_freeN(me->bb);
174
154
        if(me->disp.first) freedisplist(&me->disp);
 
155
        if(me->derived) me->derived->release(me->derived);
175
156
}
176
157
 
177
158
void copy_dverts(MDeformVert *dst, MDeformVert *src, int copycount)
238
219
                id_us_plus((ID *)men->mat[a]);
239
220
        }
240
221
        id_us_plus((ID *)men->texcomesh);
 
222
 
 
223
        men->mvert= MEM_dupallocN(me->mvert);
 
224
        men->medge= MEM_dupallocN(me->medge);
241
225
        men->mface= MEM_dupallocN(me->mface);
242
 
 
243
226
        men->tface= MEM_dupallocN(me->tface);
 
227
        men->dface= NULL;
244
228
 
245
 
        men->dface= 0;
246
 
        men->mvert= MEM_dupallocN(me->mvert);
247
 
        memcpy (men->mvert, me->mvert, sizeof (MVert)*me->totvert);
248
229
        if (me->dvert){
249
230
                men->dvert = MEM_mallocN (sizeof (MDeformVert)*me->totvert, "MDeformVert");
250
231
                copy_dverts(men->dvert, me->dvert, me->totvert);
252
233
 
253
234
        men->mcol= MEM_dupallocN(me->mcol);
254
235
        men->msticky= MEM_dupallocN(me->msticky);
255
 
        men->texcomesh= 0;
256
 
        men->orco= 0;
 
236
        men->texcomesh= NULL;
 
237
        men->orco= NULL;
257
238
        men->bb= MEM_dupallocN(men->bb);
258
239
        
259
 
        copy_displist(&men->disp, &me->disp);
 
240
        men->disp.first= men->disp.last= NULL;  // dont copy, editmode version has pointers in it
260
241
        
261
242
        men->key= copy_key(me->key);
262
243
        if(men->key) men->key->from= (ID *)men;
263
244
        
 
245
        men->derived = NULL;
 
246
        men->decimated = NULL;
 
247
 
264
248
        return men;
265
249
}
266
250
 
443
427
void make_orco_displist_mesh(Object *ob, int subdivlvl)
444
428
{
445
429
        Mesh *me;
 
430
        DerivedMesh *dm;
446
431
        DispListMesh *dlm;
447
432
        int i;
448
433
        
449
434
        me= ob->data;
450
435
 
451
 
                /* if there's a key, set the first one */
452
 
        if(me->key && me->texcomesh==0) {
453
 
                cp_key(0, me->totvert, me->totvert, (char*) me->mvert->co, me->key, me->key->refkey, 0);
 
436
        if (G.obedit && G.obedit->data==me) {
 
437
                dm= subsurf_make_derived_from_editmesh(G.editMesh, subdivlvl, me->subsurftype, NULL);
 
438
                dlm= dm->convertToDispListMesh(dm);
 
439
                dm->release(dm);
 
440
        } else {
 
441
                        /* if there's a key, set the first one */
 
442
                if(me->key && me->texcomesh==0) {
 
443
                        cp_key(0, me->totvert, me->totvert, (char*) me->mvert->co, me->key, me->key->refkey, 0);
 
444
                }
 
445
 
 
446
                dm= subsurf_make_derived_from_mesh(me, subdivlvl);
 
447
                dlm= dm->convertToDispListMesh(dm);
 
448
                dm->release(dm);
 
449
                
 
450
                        /* Restore correct key */
 
451
                do_ob_key(ob);
454
452
        }
455
453
 
456
 
        dlm= subsurf_make_dispListMesh_from_mesh(me, NULL, subdivlvl, me->flag);
457
 
        
458
 
                /* Restore correct key */
459
 
        do_ob_key(ob);
460
 
 
461
454
        if (me->orco) MEM_freeN(me->orco);
462
455
        me->orco= MEM_mallocN(dlm->totvert*3*sizeof(float), "mesh displist orco");
463
456
        
784
777
        test_object_materials((ID *)me);
785
778
}
786
779
 
 
780
/* ************** make edges in a Mesh, for outside of editmode */
 
781
 
 
782
struct edgesort {
 
783
        int v1, v2;
 
784
        int flag;
 
785
};
 
786
 
 
787
/* edges have to be added with lowest index first for sorting */
 
788
static void to_edgesort(struct edgesort *ed, int v1, int v2, int flag)
 
789
{
 
790
        if(v1<v2) {
 
791
                ed->v1= v1; ed->v2= v2;
 
792
        }
 
793
        else {
 
794
                ed->v1= v2; ed->v2= v1;
 
795
        }
 
796
        ed->flag= flag;
 
797
}
 
798
 
 
799
static int vergedgesort(const void *v1, const void *v2)
 
800
{
 
801
        const struct edgesort *x1=v1, *x2=v2;
 
802
 
 
803
        if( x1->v1 > x2->v1) return 1;
 
804
        else if( x1->v1 < x2->v1) return -1;
 
805
        else if( x1->v2 > x2->v2) return 1;
 
806
        else if( x1->v2 < x2->v2) return -1;
 
807
        
 
808
        return 0;
 
809
}
 
810
 
 
811
 
 
812
void make_edges(Mesh *me)
 
813
{
 
814
        MFace *mface;
 
815
        MEdge *medge;
 
816
        struct edgesort *edsort, *ed;
 
817
        int a, totedge=0, final=0;
 
818
        
 
819
        /* we put all edges in array, sort them, and detect doubles that way */
 
820
        
 
821
        for(a= me->totface, mface= me->mface; a>0; a--, mface++) {
 
822
                if(mface->v4) totedge+=4;
 
823
                else if(mface->v3) totedge+=3;
 
824
                else totedge+=1;
 
825
        }
 
826
        
 
827
        if(totedge==0) return;
 
828
        
 
829
        ed= edsort= MEM_mallocN(totedge*sizeof(struct edgesort), "edgesort");
 
830
        
 
831
        for(a= me->totface, mface= me->mface; a>0; a--, mface++) {
 
832
                
 
833
                to_edgesort(ed, mface->v1, mface->v2, mface->edcode & ME_V1V2);
 
834
                ed++;
 
835
                if(mface->v4) {
 
836
                        to_edgesort(ed, mface->v2, mface->v3, mface->edcode & ME_V2V3);
 
837
                        ed++;
 
838
                        to_edgesort(ed, mface->v3, mface->v4, mface->edcode & ME_V3V4);
 
839
                        ed++;
 
840
                        to_edgesort(ed, mface->v4, mface->v1, mface->edcode & ME_V4V1);
 
841
                        ed++;
 
842
                }
 
843
                else if(mface->v3) {
 
844
                        to_edgesort(ed, mface->v2, mface->v3, mface->edcode & ME_V2V3);
 
845
                        ed++;
 
846
                        to_edgesort(ed, mface->v3, mface->v1, mface->edcode & ME_V3V1);
 
847
                        ed++;
 
848
                }
 
849
        }
 
850
        
 
851
        qsort(edsort, totedge, sizeof(struct edgesort), vergedgesort);
 
852
        
 
853
        /* count final amount */
 
854
        for(a=totedge, ed=edsort; a>1; a--, ed++) {
 
855
                /* edge is unique when it differs from next edge, or is last */
 
856
                if(ed->v1 != (ed+1)->v1 || ed->v2 != (ed+1)->v2) final++;
 
857
                else {
 
858
                        /* this makes sure identical edges both get draw flag */
 
859
                        if(ed->flag) (ed+1)->flag= 1;
 
860
                        else if((ed+1)->flag) ed->flag= 1;
 
861
                }
 
862
        }
 
863
        final++;
 
864
        
 
865
        medge= me->medge= MEM_callocN(final*sizeof(MEdge), "make mesh edges");
 
866
        me->totedge= final;
 
867
        
 
868
        for(a=totedge, ed=edsort; a>1; a--, ed++) {
 
869
                /* edge is unique when it differs from next edge, or is last */
 
870
                if(ed->v1 != (ed+1)->v1 || ed->v2 != (ed+1)->v2) {
 
871
                        medge->v1= ed->v1;
 
872
                        medge->v2= ed->v2;
 
873
                        if(ed->flag) medge->flag= ME_EDGEDRAW;
 
874
                        medge++;
 
875
                }
 
876
        }
 
877
        /* last edge */
 
878
        medge->v1= ed->v1;
 
879
        medge->v2= ed->v2;
 
880
        if(ed->flag) medge->flag= ME_EDGEDRAW;
 
881
 
 
882
        MEM_freeN(edsort);
 
883
}
 
884
 
 
885
 
 
886
 
787
887
void mball_to_mesh(ListBase *lb, Mesh *me)
788
888
{
789
889
        DispList *dl;
851
951
                /* rule: dl->type INDEX3 always as first in list */
852
952
                dl= cu->disp.first;
853
953
                if(dl->type!=DL_INDEX3) {
854
 
                        curve_to_filledpoly(ob->data, &cu->disp);
 
954
                        curve_to_filledpoly(ob->data, &cu->nurb, &cu->disp);
855
955
                }
856
956
        }
857
957
 
1109
1209
}
1110
1210
 
1111
1211
int mesh_uses_displist(Mesh *me) {
1112
 
        return (me->flag&ME_SUBSURF);
 
1212
        return (me->flag&ME_SUBSURF) && me->subdiv;
1113
1213
}
1114
1214
 
1115
1215
void mesh_calculate_vertex_normals(Mesh *me)