← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/blender/intrepid-updates

« back to all changes in this revision

Viewing changes to source/blender/src/editdeform.c

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2008-08-08 02:45:40 UTC
  • mfrom: (12.1.14 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080808024540-kkjp7ekfivzhuw3l
Tags: 2.46+dfsg-4
http://bugs.debian.org/492280
* Fix python syntax warning in import_dxf.py, which led to nasty output
  in installation/upgrade logs during byte-compilation, using a patch
  provided by the script author (Closes: #492280):
   - debian/patches/45_fix_python_syntax_warning

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/editdeform.c
1
1
/**
2
 
 * $Id: editdeform.c,v 1.26 2005/12/19 11:55:31 ton Exp $
 
2
 * $Id: editdeform.c 14776 2008-05-10 12:33:15Z blendix $
3
3
 *
4
 
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 
4
 * ***** BEGIN GPL LICENSE BLOCK *****
5
5
 *
6
6
 * This program is free software; you can redistribute it and/or
7
7
 * modify it under the terms of the GNU General Public License
8
8
 * as published by the Free Software Foundation; either version 2
9
 
 * of the License, or (at your option) any later version. The Blender
10
 
 * Foundation also sells licenses for use in proprietary software under
11
 
 * the Blender License.  See http://www.blender.org/BL/ for information
12
 
 * about this.
 
9
 * of the License, or (at your option) any later version.
13
10
 *
14
11
 * This program is distributed in the hope that it will be useful,
15
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27
24
 *
28
25
 * Contributor(s): none yet.
29
26
 *
30
 
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 
27
 * ***** END GPL LICENSE BLOCK *****
31
28
 * Creator-specific support for vertex deformation groups
32
29
 * Added: apply deform function (ton)
33
30
 */
36
33
 
37
34
#include "MEM_guardedalloc.h"
38
35
 
 
36
#include "DNA_cloth_types.h"
39
37
#include "DNA_curve_types.h"
 
38
#include "DNA_lattice_types.h"
40
39
#include "DNA_mesh_types.h"
41
40
#include "DNA_meshdata_types.h"
 
41
#include "DNA_modifier_types.h"
42
42
#include "DNA_object_types.h"
 
43
#include "DNA_object_force.h"
 
44
#include "DNA_particle_types.h"
43
45
 
44
46
#include "BLI_blenlib.h"
45
47
#include "BLI_editVert.h"
46
48
 
 
49
#include "BKE_customdata.h"
47
50
#include "BKE_DerivedMesh.h"
48
51
#include "BKE_depsgraph.h"
49
 
#include "BKE_global.h"
50
52
#include "BKE_deform.h"
51
53
#include "BKE_displist.h"
 
54
#include "BKE_global.h"
 
55
#include "BKE_lattice.h"
52
56
#include "BKE_mesh.h"
 
57
#include "BKE_utildefines.h"
53
58
 
 
59
#include "BIF_interface.h"
54
60
#include "BIF_editdeform.h"
55
61
#include "BIF_editmesh.h"
 
62
#include "BIF_space.h"
56
63
#include "BIF_toolbox.h"
57
64
 
58
65
#include "BSE_edit.h"
59
66
 
 
67
#include "butspace.h"
 
68
#include "mydevice.h"
 
69
#include "editmesh.h"
 
70
#include "multires.h"
 
71
 
60
72
#ifdef HAVE_CONFIG_H
61
73
#include <config.h>
62
74
#endif
63
75
 
64
 
/* ----------------- function prototypes ---------------- */
65
 
void remove_vert_def_nr (Object *, int , int );
66
 
void add_vert_defnr (Object *, int , int vertnum, float , int );
67
 
 
68
 
 
 
76
/* only in editmode */
69
77
void sel_verts_defgroup (int select)
70
78
{
71
 
        EditMesh *em = G.editMesh;
72
 
        EditVert                *eve;
73
 
        Object                  *ob;
74
 
        int                             i;
 
79
        EditVert *eve;
 
80
        Object *ob;
 
81
        int i;
 
82
        MDeformVert *dvert;
75
83
 
76
 
        ob=G.obedit;
 
84
        ob= G.obedit;
77
85
 
78
86
        if (!ob)
79
87
                return;
80
88
 
81
89
        switch (ob->type){
82
90
        case OB_MESH:
83
 
                for (eve=em->verts.first; eve; eve=eve->next){
84
 
                        if (eve->totweight){
85
 
                                for (i=0; i<eve->totweight; i++){
86
 
                                        if (eve->dw[i].def_nr == (ob->actdef-1)){
 
91
                for (eve=G.editMesh->verts.first; eve; eve=eve->next){
 
92
                        dvert= CustomData_em_get(&G.editMesh->vdata, eve->data, CD_MDEFORMVERT);
 
93
 
 
94
                        if (dvert && dvert->totweight){
 
95
                                for (i=0; i<dvert->totweight; i++){
 
96
                                        if (dvert->dw[i].def_nr == (ob->actdef-1)){
87
97
                                                if (select) eve->f |= SELECT;
88
98
                                                else eve->f &= ~SELECT;
89
99
                                                
92
102
                                }
93
103
                        }
94
104
                }
95
 
                break;
 
105
                /* this has to be called, because this function operates on vertices only */
 
106
                if(select) EM_select_flush();   // vertices to edges/faces
 
107
                else EM_deselect_flush();
 
108
                
 
109
                break;
 
110
        case OB_LATTICE:
 
111
                if(editLatt->dvert) {
 
112
                        BPoint *bp;
 
113
                        int a, tot;
 
114
                        
 
115
                        dvert= editLatt->dvert;
 
116
 
 
117
                        tot= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
 
118
                        for(a=0, bp= editLatt->def; a<tot; a++, bp++, dvert++) {
 
119
                                for (i=0; i<dvert->totweight; i++){
 
120
                                        if (dvert->dw[i].def_nr == (ob->actdef-1)) {
 
121
                                                if(select) bp->f1 |= SELECT;
 
122
                                                else bp->f1 &= ~SELECT;
 
123
                                                
 
124
                                                break;
 
125
                                        }
 
126
                                }
 
127
                        }
 
128
                }       
 
129
                break;
 
130
                
96
131
        default:
97
132
                break;
98
133
        }
 
134
        
99
135
        countall();
100
 
        /* this has to be called, because this function operates on vertices only */
101
 
        if(select) EM_select_flush();   // vertices to edges/faces
102
 
        else EM_deselect_flush();
 
136
        
 
137
}
 
138
 
 
139
/* check if deform vertex has defgroup index */
 
140
MDeformWeight *get_defweight (MDeformVert *dv, int defgroup)
 
141
{
 
142
        int i;
 
143
        
 
144
        if (!dv || defgroup<0)
 
145
                return NULL;
 
146
        
 
147
        for (i=0; i<dv->totweight; i++){
 
148
                if (dv->dw[i].def_nr == defgroup)
 
149
                        return dv->dw+i;
 
150
        }
 
151
        return NULL;
103
152
}
104
153
 
105
154
/* Ensures that mv has a deform weight entry for
108
157
MDeformWeight *verify_defweight (MDeformVert *dv, int defgroup)
109
158
{
110
159
        MDeformWeight *newdw;
111
 
        int     i;
112
160
 
 
161
        /* do this check always, this function is used to check for it */
113
162
        if (!dv || defgroup<0)
114
163
                return NULL;
115
 
 
116
 
        for (i=0; i<dv->totweight; i++){
117
 
                if (dv->dw[i].def_nr == defgroup)
118
 
                        return dv->dw+i;
119
 
        }
120
 
 
 
164
        
 
165
        newdw = get_defweight (dv, defgroup);
 
166
        if (newdw)
 
167
                return newdw;
 
168
        
121
169
        newdw = MEM_callocN (sizeof(MDeformWeight)*(dv->totweight+1), "deformWeight");
122
170
        if (dv->dw){
123
171
                memcpy (newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
125
173
        }
126
174
        dv->dw=newdw;
127
175
        
128
 
        dv->dw[dv->totweight].weight=0;
 
176
        dv->dw[dv->totweight].weight=0.0f;
129
177
        dv->dw[dv->totweight].def_nr=defgroup;
130
178
        /* Group index */
131
179
        
158
206
        return defgroup;
159
207
}
160
208
 
 
209
void duplicate_defgroup ( Object *ob )
 
210
{
 
211
        bDeformGroup *dg, *cdg;
 
212
        char name[32], s[32];
 
213
        MDeformWeight *org, *cpy;
 
214
        MDeformVert *dvert;
 
215
        Mesh *me;
 
216
        int i, idg, icdg;
 
217
 
 
218
        if (ob->type != OB_MESH)
 
219
                return;
 
220
 
 
221
        dg = BLI_findlink (&ob->defbase, (ob->actdef-1));
 
222
        if (!dg)
 
223
                return;
 
224
        
 
225
        if (strstr(dg->name, "_copy")) {
 
226
                BLI_strncpy (name, dg->name, 32); /* will be renamed _copy.001... etc */
 
227
        } else {
 
228
                BLI_snprintf (name, 32, "%s_copy", dg->name);
 
229
                while (get_named_vertexgroup (ob, name)) {
 
230
                        if ((strlen (name) + 6) > 32) {
 
231
                                error ("Error: the name for the new group is > 32 characters");
 
232
                                return;
 
233
                        }
 
234
                        strcpy (s, name);
 
235
                        BLI_snprintf (name, 32, "%s_copy", s);
 
236
                }
 
237
        }               
 
238
 
 
239
        cdg = copy_defgroup (dg);
 
240
        strcpy (cdg->name, name);
 
241
        unique_vertexgroup_name(cdg, ob);
 
242
        
 
243
        BLI_addtail (&ob->defbase, cdg);
 
244
 
 
245
        idg = (ob->actdef-1);
 
246
        ob->actdef = BLI_countlist (&ob->defbase);
 
247
        icdg = (ob->actdef-1);
 
248
 
 
249
        me = get_mesh (ob);
 
250
        if (!me->dvert)
 
251
                return;
 
252
 
 
253
        for (i = 0; i < me->totvert; i++) {
 
254
                dvert = me->dvert+i;
 
255
                org = get_defweight (dvert, idg);
 
256
                if (org) {
 
257
                        cpy = verify_defweight (dvert, icdg);
 
258
                        cpy->weight = org->weight;
 
259
                }
 
260
        }
 
261
}
 
262
 
 
263
static void del_defgroup_update_users(Object *ob, int id)
 
264
{
 
265
        ExplodeModifierData *emd;
 
266
        ModifierData *md;
 
267
        ParticleSystem *psys;
 
268
        ClothModifierData *clmd;
 
269
        ClothSimSettings *clsim;
 
270
        int a;
 
271
 
 
272
        /* these cases don't use names to refer to vertex groups, so when
 
273
         * they get deleted the numbers get out of synce, this corrects that */
 
274
 
 
275
        if(ob->soft) {
 
276
                if(ob->soft->vertgroup == id)
 
277
                        ob->soft->vertgroup= 0;
 
278
                else if(ob->soft->vertgroup > id)
 
279
                        ob->soft->vertgroup--;
 
280
        }
 
281
 
 
282
        for(md=ob->modifiers.first; md; md=md->next) {
 
283
                if(md->type == eModifierType_Explode) {
 
284
                        emd= (ExplodeModifierData*)md;
 
285
 
 
286
                        if(emd->vgroup == id)
 
287
                                emd->vgroup= 0;
 
288
                        else if(emd->vgroup > id)
 
289
                                emd->vgroup--;
 
290
                }
 
291
                else if(md->type == eModifierType_Cloth) {
 
292
                        clmd= (ClothModifierData*)md;
 
293
                        clsim= clmd->sim_parms;
 
294
 
 
295
                        if(clsim) {
 
296
                                if(clsim->vgroup_mass == id)
 
297
                                        clsim->vgroup_mass= 0;
 
298
                                else if(clsim->vgroup_mass > id)
 
299
                                        clsim->vgroup_mass--;
 
300
 
 
301
                                if(clsim->vgroup_bend == id)
 
302
                                        clsim->vgroup_bend= 0;
 
303
                                else if(clsim->vgroup_bend > id)
 
304
                                        clsim->vgroup_bend--;
 
305
 
 
306
                                if(clsim->vgroup_struct == id)
 
307
                                        clsim->vgroup_struct= 0;
 
308
                                else if(clsim->vgroup_struct > id)
 
309
                                        clsim->vgroup_struct--;
 
310
                        }
 
311
                }
 
312
        }
 
313
 
 
314
        for(psys=ob->particlesystem.first; psys; psys=psys->next) {
 
315
                for(a=0; a<PSYS_TOT_VG; a++)
 
316
                        if(psys->vgroup[a] == id)
 
317
                                psys->vgroup[a]= 0;
 
318
                        else if(psys->vgroup[a] > id)
 
319
                                psys->vgroup[a]--;
 
320
        }
 
321
}
 
322
 
 
323
void del_defgroup_in_object_mode ( Object *ob )
 
324
{
 
325
        bDeformGroup *dg;
 
326
        MDeformVert *dvert;
 
327
        Mesh *me;
 
328
        int i, e;
 
329
 
 
330
        if ((!ob) || (ob->type != OB_MESH))
 
331
                return;
 
332
 
 
333
        dg = BLI_findlink (&ob->defbase, (ob->actdef-1));
 
334
        if (!dg)
 
335
                return;
 
336
 
 
337
        me = get_mesh (ob);
 
338
        if (me->dvert) {
 
339
                for (i = 0; i < me->totvert; i++) {
 
340
                        dvert = me->dvert + i;
 
341
                        if (dvert) {
 
342
                                if (get_defweight (dvert, (ob->actdef-1)))
 
343
                                        remove_vert_defgroup (ob, dg, i);
 
344
                        }
 
345
                }
 
346
 
 
347
                for (i = 0; i < me->totvert; i++) {
 
348
                        dvert = me->dvert+i;
 
349
                        if (dvert) {
 
350
                                for (e = 0; e < dvert->totweight; e++) {
 
351
                                        if (dvert->dw[e].def_nr > (ob->actdef-1))
 
352
                                                dvert->dw[e].def_nr--;
 
353
                                }
 
354
                        }
 
355
                }
 
356
        }
 
357
 
 
358
        del_defgroup_update_users(ob, ob->actdef);
 
359
 
 
360
        /* Update the active deform index if necessary */
 
361
        if (ob->actdef == BLI_countlist(&ob->defbase))
 
362
                ob->actdef--;
 
363
  
 
364
        /* Remove the group */
 
365
        BLI_freelinkN (&ob->defbase, dg);
 
366
}
 
367
 
161
368
void del_defgroup (Object *ob)
162
369
{
163
 
        EditMesh *em = G.editMesh;
164
370
        bDeformGroup    *defgroup;
165
 
        EditVert                *eve;
166
371
        int                             i;
167
372
 
168
 
 
169
373
        if (!ob)
170
374
                return;
171
375
 
180
384
        remove_verts_defgroup(1);
181
385
 
182
386
        /* Make sure that any verts with higher indices are adjusted accordingly */
183
 
        for (eve=em->verts.first; eve; eve=eve->next){
184
 
                for (i=0; i<eve->totweight; i++){
185
 
                        if (eve->dw[i].def_nr > (ob->actdef-1))
186
 
                                eve->dw[i].def_nr--;
187
 
                }
188
 
        }
189
 
 
190
 
        /* Update the active material index if necessary */
 
387
        if(ob->type==OB_MESH) {
 
388
                EditMesh *em = G.editMesh;
 
389
                EditVert *eve;
 
390
                MDeformVert *dvert;
 
391
                
 
392
                for (eve=em->verts.first; eve; eve=eve->next){
 
393
                        dvert= CustomData_em_get(&G.editMesh->vdata, eve->data, CD_MDEFORMVERT);
 
394
 
 
395
                        if (dvert)
 
396
                                for (i=0; i<dvert->totweight; i++)
 
397
                                        if (dvert->dw[i].def_nr > (ob->actdef-1))
 
398
                                                dvert->dw[i].def_nr--;
 
399
                }
 
400
        }
 
401
        else {
 
402
                BPoint *bp;
 
403
                MDeformVert *dvert= editLatt->dvert;
 
404
                int a, tot;
 
405
                
 
406
                if (dvert) {
 
407
                        tot= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
 
408
                        for(a=0, bp= editLatt->def; a<tot; a++, bp++, dvert++) {
 
409
                                for (i=0; i<dvert->totweight; i++){
 
410
                                        if (dvert->dw[i].def_nr > (ob->actdef-1))
 
411
                                                dvert->dw[i].def_nr--;
 
412
                                }
 
413
                        }
 
414
                }
 
415
        }
 
416
 
 
417
        del_defgroup_update_users(ob, ob->actdef);
 
418
 
 
419
        /* Update the active deform index if necessary */
191
420
        if (ob->actdef==BLI_countlist(&ob->defbase))
192
421
                ob->actdef--;
193
422
        
196
425
        
197
426
        /* remove all dverts */
198
427
        if(ob->actdef==0) {
199
 
                Mesh *me= ob->data;
200
 
                free_dverts(me->dvert, me->totvert);
201
 
                me->dvert= NULL;
 
428
                if(ob->type==OB_MESH) {
 
429
                        Mesh *me= ob->data;
 
430
                        CustomData_free_layer_active(&me->vdata, CD_MDEFORMVERT, me->totvert);
 
431
                        me->dvert= NULL;
 
432
                }
 
433
                else {
 
434
                        if (editLatt->dvert) {
 
435
                                MEM_freeN(editLatt->dvert);
 
436
                                editLatt->dvert= NULL;
 
437
                        }
 
438
                }
202
439
        }
203
440
}
204
441
 
205
 
void create_dverts(Mesh *me)
 
442
void create_dverts(ID *id)
206
443
{
207
 
        /* create deform verts for the mesh
 
444
        /* create deform verts
208
445
         */
209
 
        int i;
210
446
 
211
 
        me->dvert= MEM_mallocN(sizeof(MDeformVert)*me->totvert, "deformVert");
212
 
        for (i=0; i < me->totvert; ++i) {
213
 
                me->dvert[i].totweight = 0;
214
 
                me->dvert[i].dw        = NULL;
 
447
        if( GS(id->name)==ID_ME) {
 
448
                Mesh *me= (Mesh *)id;
 
449
                me->dvert= CustomData_add_layer(&me->vdata, CD_MDEFORMVERT, CD_CALLOC, NULL, me->totvert);
 
450
        }
 
451
        else if( GS(id->name)==ID_LT) {
 
452
                Lattice *lt= (Lattice *)id;
 
453
                lt->dvert= MEM_callocN(sizeof(MDeformVert)*lt->pntsu*lt->pntsv*lt->pntsw, "lattice deformVert");
215
454
        }
216
455
}
217
456
 
 
457
/* for mesh in object mode
 
458
   lattice can be in editmode */
218
459
void remove_vert_def_nr (Object *ob, int def_nr, int vertnum)
219
460
{
220
461
        /* This routine removes the vertex from the deform
228
469
         */
229
470
 
230
471
        MDeformWeight *newdw;
231
 
        MDeformVert *dvert;
 
472
        MDeformVert *dvert= NULL;
232
473
        int i;
233
474
 
234
 
        /* if this mesh has no deform mesh abort
235
 
         */
236
 
        if (!((Mesh*)ob->data)->dvert) return;
237
 
 
238
 
        /* get the deform mesh cooresponding to the
 
475
        /* get the deform vertices corresponding to the
239
476
         * vertnum
240
477
         */
241
 
        dvert = ((Mesh*)ob->data)->dvert + vertnum;
242
 
 
 
478
        if(ob->type==OB_MESH) {
 
479
                if( ((Mesh*)ob->data)->dvert )
 
480
                        dvert = ((Mesh*)ob->data)->dvert + vertnum;
 
481
        }
 
482
        else if(ob->type==OB_LATTICE) {
 
483
                Lattice *lt= ob->data;
 
484
                
 
485
                if(ob==G.obedit)
 
486
                        lt= editLatt;
 
487
                
 
488
                if(lt->dvert)
 
489
                        dvert = lt->dvert + vertnum;
 
490
        }
 
491
        
 
492
        if(dvert==NULL)
 
493
                return;
 
494
        
243
495
        /* for all of the deform weights in the
244
496
         * deform vert
245
497
         */
273
525
                        else {
274
526
                                MEM_freeN (dvert->dw);
275
527
                                dvert->dw = NULL;
 
528
                                break;
276
529
                        }
277
530
                }
278
531
        }
279
532
 
280
533
}
281
534
 
 
535
/* for Mesh in Object mode */
 
536
/* allows editmode for Lattice */
282
537
void add_vert_defnr (Object *ob, int def_nr, int vertnum, 
283
538
                           float weight, int assignmode)
284
539
{
285
540
        /* add the vert to the deform group with the
286
541
         * specified number
287
542
         */
288
 
 
289
 
        MDeformVert *dv;
 
543
        MDeformVert *dv= NULL;
290
544
        MDeformWeight *newdw;
291
545
        int     i;
292
546
 
293
 
        /* get the vert
294
 
         */
295
 
        if(((Mesh*)ob->data)->dvert)
296
 
                dv = ((Mesh*)ob->data)->dvert + vertnum;
297
 
        else 
 
547
        /* get the vert */
 
548
        if(ob->type==OB_MESH) {
 
549
                if(((Mesh*)ob->data)->dvert)
 
550
                        dv = ((Mesh*)ob->data)->dvert + vertnum;
 
551
        }
 
552
        else if(ob->type==OB_LATTICE) {
 
553
                Lattice *lt;
 
554
                
 
555
                if(ob==G.obedit)
 
556
                        lt= editLatt;
 
557
                else
 
558
                        lt= ob->data;
 
559
                        
 
560
                if(lt->dvert)
 
561
                        dv = lt->dvert + vertnum;
 
562
        }
 
563
        
 
564
        if(dv==NULL)
298
565
                return;
299
566
        
300
567
        /* Lets first check to see if this vert is
363
630
        }
364
631
}
365
632
 
 
633
/* called while not in editmode */
366
634
void add_vert_to_defgroup (Object *ob, bDeformGroup *dg, int vertnum, 
367
635
                           float weight, int assignmode)
368
636
{
377
645
        def_nr = get_defgroup_num(ob, dg);
378
646
        if (def_nr < 0) return;
379
647
 
380
 
        /* if this mesh has no deform verts then
 
648
        /* if there's no deform verts then
381
649
         * create some
382
650
         */
383
 
        if (!((Mesh*)ob->data)->dvert) {
384
 
                create_dverts((Mesh*)ob->data);
 
651
        if(ob->type==OB_MESH) {
 
652
                if (!((Mesh*)ob->data)->dvert)
 
653
                        create_dverts(ob->data);
 
654
        }
 
655
        else if(ob->type==OB_LATTICE) {
 
656
                if (!((Lattice*)ob->data)->dvert)
 
657
                        create_dverts(ob->data);
385
658
        }
386
659
 
387
660
        /* call another function to do the work
389
662
        add_vert_defnr (ob, def_nr, vertnum, weight, assignmode);
390
663
}
391
664
 
392
 
 
 
665
/* Only available in editmode */
393
666
void assign_verts_defgroup (void)
394
 
/* Only available in editmode */
395
667
{
396
 
        EditMesh *em = G.editMesh;
397
 
        Object *ob;
398
 
        EditVert *eve;
399
 
        bDeformGroup    *dg, *eg;
400
668
        extern float editbutvweight;    /* buttons.c */
 
669
        Object *ob;
 
670
        EditVert *eve;
 
671
        bDeformGroup *dg, *eg;
 
672
        MDeformWeight *newdw;
 
673
        MDeformVert *dvert;
401
674
        int     i, done;
402
 
        MDeformWeight *newdw;
 
675
        
 
676
        if(multires_level1_test()) return;
403
677
 
404
 
        ob=G.obedit;
 
678
        ob= G.obedit;
405
679
 
406
680
        if (!ob)
407
681
                return;
414
688
 
415
689
        switch (ob->type){
416
690
        case OB_MESH:
 
691
                if (!CustomData_has_layer(&G.editMesh->vdata, CD_MDEFORMVERT))
 
692
                        EM_add_data_layer(&G.editMesh->vdata, CD_MDEFORMVERT);
 
693
 
417
694
                /* Go through the list of editverts and assign them */
418
 
                for (eve=em->verts.first; eve; eve=eve->next){
419
 
                        if (eve->f & 1){
 
695
                for (eve=G.editMesh->verts.first; eve; eve=eve->next){
 
696
                        dvert= CustomData_em_get(&G.editMesh->vdata, eve->data, CD_MDEFORMVERT);
 
697
 
 
698
                        if (dvert && (eve->f & 1)){
420
699
                                done=0;
421
700
                                /* See if this vert already has a reference to this group */
422
701
                                /*              If so: Change its weight */
423
702
                                done=0;
424
 
                                for (i=0; i<eve->totweight; i++){
425
 
                                        eg = BLI_findlink (&ob->defbase, eve->dw[i].def_nr);
 
703
                                for (i=0; i<dvert->totweight; i++){
 
704
                                        eg = BLI_findlink (&ob->defbase, dvert->dw[i].def_nr);
426
705
                                        /* Find the actual group */
427
706
                                        if (eg==dg){
428
 
                                                eve->dw[i].weight=editbutvweight;
 
707
                                                dvert->dw[i].weight=editbutvweight;
429
708
                                                done=1;
430
709
                                                break;
431
710
                                        }
432
711
                                }
433
712
                                /*              If not: Add the group and set its weight */
434
713
                                if (!done){
435
 
                                        newdw = MEM_callocN (sizeof(MDeformWeight)*(eve->totweight+1), "deformWeight");
436
 
                                        if (eve->dw){
437
 
                                                memcpy (newdw, eve->dw, sizeof(MDeformWeight)*eve->totweight);
438
 
                                                MEM_freeN (eve->dw);
 
714
                                        newdw = MEM_callocN (sizeof(MDeformWeight)*(dvert->totweight+1), "deformWeight");
 
715
                                        if (dvert->dw){
 
716
                                                memcpy (newdw, dvert->dw, sizeof(MDeformWeight)*dvert->totweight);
 
717
                                                MEM_freeN (dvert->dw);
439
718
                                        }
440
 
                                        eve->dw=newdw;
441
 
 
442
 
                                        eve->dw[eve->totweight].weight=editbutvweight;
443
 
                                        eve->dw[eve->totweight].def_nr=ob->actdef-1;
444
 
 
445
 
                                        eve->totweight++;
 
719
                                        dvert->dw=newdw;
 
720
 
 
721
                                        dvert->dw[dvert->totweight].weight= editbutvweight;
 
722
                                        dvert->dw[dvert->totweight].def_nr= ob->actdef-1;
 
723
 
 
724
                                        dvert->totweight++;
446
725
 
447
726
                                }
448
727
                        }
449
728
                }
450
729
                break;
 
730
        case OB_LATTICE:
 
731
                {
 
732
                        BPoint *bp;
 
733
                        int a, tot;
 
734
                        
 
735
                        if(editLatt->dvert==NULL)
 
736
                                create_dverts(&editLatt->id);
 
737
                        
 
738
                        tot= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
 
739
                        for(a=0, bp= editLatt->def; a<tot; a++, bp++) {
 
740
                                if(bp->f1 & SELECT)
 
741
                                        add_vert_defnr (ob, ob->actdef-1, a, editbutvweight, WEIGHT_REPLACE);
 
742
                        }
 
743
                }       
 
744
                break;
451
745
        default:
452
746
                printf ("Assigning deformation groups to unknown object type\n");
453
747
                break;
455
749
 
456
750
}
457
751
 
 
752
/* mesh object mode, lattice can be in editmode */
458
753
void remove_vert_defgroup (Object *ob, bDeformGroup     *dg, int vertnum)
459
754
{
460
755
        /* This routine removes the vertex from the specified
468
763
        if (!ob)
469
764
                return;
470
765
 
471
 
        /* if this isn't a mesh abort
472
 
         */
473
 
        if (ob->type != OB_MESH) return;
474
 
 
475
766
        /* get the deform number that cooresponds
476
767
         * to this deform group, and abort if it
477
768
         * can not be found.
484
775
        remove_vert_def_nr (ob, def_nr, vertnum);
485
776
}
486
777
 
 
778
/* for mesh in object mode lattice can be in editmode */
 
779
static float get_vert_def_nr (Object *ob, int def_nr, int vertnum)
 
780
{
 
781
        MDeformVert *dvert= NULL;
 
782
        int i;
 
783
 
 
784
        /* get the deform vertices corresponding to the
 
785
         * vertnum
 
786
         */
 
787
        if(ob->type==OB_MESH) {
 
788
                if( ((Mesh*)ob->data)->dvert )
 
789
                        dvert = ((Mesh*)ob->data)->dvert + vertnum;
 
790
        }
 
791
        else if(ob->type==OB_LATTICE) {
 
792
                Lattice *lt= ob->data;
 
793
                
 
794
                if(ob==G.obedit)
 
795
                        lt= editLatt;
 
796
                
 
797
                if(lt->dvert)
 
798
                        dvert = lt->dvert + vertnum;
 
799
        }
 
800
        
 
801
        if(dvert==NULL)
 
802
                return 0.0f;
 
803
        
 
804
        for(i=dvert->totweight-1 ; i>=0 ; i--)
 
805
                if(dvert->dw[i].def_nr == def_nr)
 
806
                        return dvert->dw[i].weight;
 
807
 
 
808
        return 0.0f;
 
809
}
 
810
 
 
811
/* mesh object mode, lattice can be in editmode */
 
812
float get_vert_defgroup (Object *ob, bDeformGroup *dg, int vertnum)
 
813
{
 
814
        int def_nr;
 
815
 
 
816
        if(!ob)
 
817
                return 0.0f;
 
818
 
 
819
        def_nr = get_defgroup_num(ob, dg);
 
820
        if(def_nr < 0) return 0.0f;
 
821
 
 
822
        return get_vert_def_nr (ob, def_nr, vertnum);
 
823
}
 
824
 
 
825
/* Only available in editmode */
 
826
/* removes from active defgroup, if allverts==0 only selected vertices */
487
827
void remove_verts_defgroup (int allverts)
488
 
/* Only available in editmode */
489
828
{
490
 
        EditMesh *em = G.editMesh;
491
829
        Object *ob;
492
830
        EditVert *eve;
 
831
        MDeformVert *dvert;
493
832
        MDeformWeight *newdw;
494
 
        bDeformGroup    *dg, *eg;
 
833
        bDeformGroup *dg, *eg;
495
834
        int     i;
 
835
        
 
836
        if(multires_level1_test()) return;
496
837
 
497
 
        ob=G.obedit;
 
838
        ob= G.obedit;
498
839
 
499
840
        if (!ob)
500
841
                return;
507
848
 
508
849
        switch (ob->type){
509
850
        case OB_MESH:
510
 
                for (eve=em->verts.first; eve; eve=eve->next){
511
 
                        if (eve->dw && ((eve->f & 1) || allverts)){
512
 
                                for (i=0; i<eve->totweight; i++){
 
851
                for (eve=G.editMesh->verts.first; eve; eve=eve->next){
 
852
                        dvert= CustomData_em_get(&G.editMesh->vdata, eve->data, CD_MDEFORMVERT);
 
853
                
 
854
                        if (dvert && dvert->dw && ((eve->f & 1) || allverts)){
 
855
                                for (i=0; i<dvert->totweight; i++){
513
856
                                        /* Find group */
514
 
                                        eg = BLI_findlink (&ob->defbase, eve->dw[i].def_nr);
 
857
                                        eg = BLI_findlink (&ob->defbase, dvert->dw[i].def_nr);
515
858
                                        if (eg == dg){
516
 
                                                eve->totweight--;
517
 
                                                if (eve->totweight){
518
 
                                                        newdw = MEM_mallocN (sizeof(MDeformWeight)*(eve->totweight), "deformWeight");
 
859
                                                dvert->totweight--;
 
860
                                                if (dvert->totweight){
 
861
                                                        newdw = MEM_mallocN (sizeof(MDeformWeight)*(dvert->totweight), "deformWeight");
519
862
                                                        
520
 
                                                        if (eve->dw){
521
 
                                                                memcpy (newdw, eve->dw, sizeof(MDeformWeight)*i);
522
 
                                                                memcpy (newdw+i, eve->dw+i+1, sizeof(MDeformWeight)*(eve->totweight-i));
523
 
                                                                MEM_freeN (eve->dw);
 
863
                                                        if (dvert->dw){
 
864
                                                                memcpy (newdw, dvert->dw, sizeof(MDeformWeight)*i);
 
865
                                                                memcpy (newdw+i, dvert->dw+i+1, sizeof(MDeformWeight)*(dvert->totweight-i));
 
866
                                                                MEM_freeN (dvert->dw);
524
867
                                                        }
525
 
                                                        eve->dw=newdw;
 
868
                                                        dvert->dw=newdw;
526
869
                                                }
527
870
                                                else{
528
 
                                                        MEM_freeN (eve->dw);
529
 
                                                        eve->dw=NULL;
 
871
                                                        MEM_freeN (dvert->dw);
 
872
                                                        dvert->dw=NULL;
 
873
                                                        break;
530
874
                                                }
531
875
                                        }
532
876
                                }
533
877
                        }
534
878
                }
535
879
                break;
 
880
        case OB_LATTICE:
 
881
                
 
882
                if(editLatt->dvert) {
 
883
                        BPoint *bp;
 
884
                        int a, tot= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
 
885
                                
 
886
                        for(a=0, bp= editLatt->def; a<tot; a++, bp++) {
 
887
                                if(allverts || (bp->f1 & SELECT))
 
888
                                        remove_vert_defgroup (ob, dg, a);
 
889
                        }
 
890
                }
 
891
                break;
 
892
                
536
893
        default:
537
894
                printf ("Removing deformation groups from unknown object type\n");
538
895
                break;
539
896
        }
540
897
}
541
898
 
542
 
void verify_defgroups (Object *ob)
543
 
{
544
 
        /* Ensure the defbase & the dverts match */
545
 
        switch (ob->type){
546
 
        case OB_MESH:
547
 
 
548
 
                /* I'm pretty sure this means "If there are no
549
 
                 * deform groups defined, yet there are deform
550
 
                 * vertices, then delete the deform vertices
551
 
                 */
552
 
                if (!ob->defbase.first){
553
 
                        if (((Mesh*)ob->data)->dvert){
554
 
                                free_dverts(((Mesh*)ob->data)->dvert, 
555
 
                                                        ((Mesh*)ob->data)->totvert);
556
 
                                ((Mesh*)ob->data)->dvert=NULL;
557
 
                        }
558
 
                }
559
 
                break;
560
 
        default:
561
 
                break;
562
 
        }
563
 
}
564
 
 
565
 
void unique_vertexgroup_name (bDeformGroup *dg, Object *ob)
566
 
{
567
 
        char            tempname[64];
568
 
        int                     number;
569
 
        char            *dot;
570
 
        int exists = 0;
571
 
        bDeformGroup *curdef;
572
 
        
573
 
        if (!ob)
574
 
                return;
575
 
        /* See if we even need to do this */
576
 
        for (curdef = ob->defbase.first; curdef; curdef=curdef->next){
577
 
                if (dg!=curdef){
578
 
                        if (!strcmp(curdef->name, dg->name)){
579
 
                                exists = 1;
580
 
                                break;
581
 
                        }
582
 
                }
583
 
        }
584
 
        
585
 
        if (!exists)
586
 
                return;
587
 
 
588
 
        /*      Strip off the suffix */
589
 
        dot=strchr(dg->name, '.');
590
 
        if (dot)
591
 
                *dot=0;
592
 
        
593
 
        for (number = 1; number <=999; number++){
594
 
                sprintf (tempname, "%s.%03d", dg->name, number);
 
899
/* Only available in editmode */
 
900
/* removes from all defgroup, if allverts==0 only selected vertices */
 
901
void remove_verts_defgroups(int allverts)
 
902
{
 
903
        Object *ob;
 
904
        int actdef, defCount;
 
905
        
 
906
        if (multires_level1_test()) return;
 
907
 
 
908
        ob= G.obedit;
 
909
        if (ob == NULL) return;
 
910
        
 
911
        actdef= ob->actdef;
 
912
        defCount= BLI_countlist(&ob->defbase);
 
913
        
 
914
        if (defCount == 0) {
 
915
                error("Object has no vertex groups");
 
916
                return;
 
917
        }
 
918
        
 
919
        /* To prevent code redundancy, we just use remove_verts_defgroup, but that
 
920
         * only operates on the active vgroup. So we iterate through all groups, by changing
 
921
         * active group index
 
922
         */
 
923
        for (ob->actdef= 1; ob->actdef <= defCount; ob->actdef++)
 
924
                remove_verts_defgroup(allverts);
595
925
                
596
 
                exists = 0;
597
 
                for (curdef=ob->defbase.first; curdef; curdef=curdef->next){
598
 
                        if (dg!=curdef){
599
 
                                if (!strcmp (curdef->name, tempname)){
600
 
                                        exists = 1;
601
 
                                        break;
602
 
                                }
603
 
                        }
604
 
                }
605
 
                if (!exists){
606
 
                        BLI_strncpy (dg->name, tempname, 32);
607
 
                        return;
608
 
                }
609
 
        }       
 
926
        ob->actdef= actdef;
610
927
}
611
928
 
612
929
void vertexgroup_select_by_name(Object *ob, char *name)
614
931
        bDeformGroup *curdef;
615
932
        int actdef= 1;
616
933
        
617
 
        if(ob==NULL || ob->type!=OB_MESH) return;
 
934
        if(ob==NULL) return;
 
935
        
618
936
        for (curdef = ob->defbase.first; curdef; curdef=curdef->next, actdef++){
619
937
                if (!strcmp(curdef->name, name)) {
620
938
                        ob->actdef= actdef;
624
942
        ob->actdef=0;   // this signals on painting to create a new one, if a bone in posemode is selected */
625
943
}
626
944
 
 
945
/* This function provides a shortcut for adding/removing verts from 
 
946
 * vertex groups. It is called by the Ctrl-G hotkey in EditMode for Meshes
 
947
 * and Lattices. (currently only restricted to those two)
 
948
 * It is only responsible for 
 
949
 */
 
950
void vgroup_assign_with_menu(void)
 
951
{
 
952
        Object *ob= G.obedit;
 
953
        int defCount;
 
954
        int mode;
 
955
        
 
956
        /* prevent crashes */
 
957
        if (ob==NULL) return;
 
958
        
 
959
        defCount= BLI_countlist(&ob->defbase);
 
960
        
 
961
        /* give user choices of adding to current/new or removing from current */
 
962
        if (defCount && ob->actdef)
 
963
                mode = pupmenu("Vertex Groups %t|Add Selected to New Group %x1|Add Selected to Active Group %x2|Remove Selected from Active Group %x3|Remove Selected from All Groups %x4");
 
964
        else
 
965
                mode= pupmenu("Vertex Groups %t|Add Selected to New Group %x1");
 
966
        
 
967
        /* handle choices */
 
968
        switch (mode) {
 
969
                case 1: /* add to new group */
 
970
                        add_defgroup(ob);
 
971
                        assign_verts_defgroup();
 
972
                        allqueue(REDRAWVIEW3D, 1);
 
973
                        BIF_undo_push("Assign to vertex group");
 
974
                        break;
 
975
                case 2: /* add to current group */
 
976
                        assign_verts_defgroup();
 
977
                        allqueue(REDRAWVIEW3D, 1);
 
978
                        BIF_undo_push("Assign to vertex group");
 
979
                        break;
 
980
                case 3: /* remove from current group */
 
981
                        remove_verts_defgroup(0);
 
982
                        allqueue(REDRAWVIEW3D, 1);
 
983
                        BIF_undo_push("Remove from vertex group");
 
984
                        break;
 
985
                case 4: /* remove from all groups */
 
986
                        remove_verts_defgroups(0);
 
987
                        allqueue(REDRAWVIEW3D, 1);
 
988
                        BIF_undo_push("Remove from all vertex groups");
 
989
                        break;
 
990
        }
 
991
}
 
992
 
 
993
/* This function provides a shortcut for commonly used vertex group 
 
994
 * functions - change weight (not implemented), change active group, delete active group,
 
995
 * when Ctrl-Shift-G is used in EditMode, for Meshes and Lattices (only for now).
 
996
 */
 
997
void vgroup_operation_with_menu(void)
 
998
{
 
999
        Object *ob= G.obedit;
 
1000
        int defCount;
 
1001
        int mode;
 
1002
        
 
1003
        /* prevent crashes and useless cases */
 
1004
        if (ob==NULL) return;
 
1005
        
 
1006
        defCount= BLI_countlist(&ob->defbase);
 
1007
        if (defCount == 0) return;
 
1008
        
 
1009
        /* give user choices of adding to current/new or removing from current */
 
1010
        if (ob->actdef)
 
1011
                mode = pupmenu("Vertex Groups %t|Change Active Group%x1|Delete Active Group%x2");
 
1012
        else
 
1013
                mode= pupmenu("Vertex Groups %t|Change Active Group%x1");
 
1014
        
 
1015
        /* handle choices */
 
1016
        switch (mode) {
 
1017
                case 1: /* change active group*/
 
1018
                        {
 
1019
                                char *menustr= get_vertexgroup_menustr(ob);
 
1020
                                short nr;
 
1021
                                
 
1022
                                if (menustr) {
 
1023
                                        nr= pupmenu(menustr);
 
1024
                                        
 
1025
                                        if ((nr >= 1) && (nr <= defCount)) 
 
1026
                                                ob->actdef= nr;
 
1027
                                                
 
1028
                                        MEM_freeN(menustr);
 
1029
                                }
 
1030
                                allqueue(REDRAWBUTSALL, 0);
 
1031
                        }
 
1032
                        break;
 
1033
                case 2: /* delete active group  */
 
1034
                        {
 
1035
                                del_defgroup(ob);
 
1036
                                allqueue (REDRAWVIEW3D, 1);
 
1037
                                allqueue(REDRAWOOPS, 0);
 
1038
                                BIF_undo_push("Delete vertex group");
 
1039
                        }
 
1040
                        break;
 
1041
        }
 
1042
}
627
1043
 
628
1044
/* ******************* other deform edit stuff ********** */
629
1045