svn merge -r40197:40311 ^/trunk/blender
[blender.git] / source / blender / editors / object / object_modifier.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation, 2009
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/object/object_modifier.c
29  *  \ingroup edobj
30  */
31
32
33 #include <math.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_curve_types.h"
40 #include "DNA_key_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_meshdata_types.h"
43 #include "DNA_object_force.h"
44 #include "DNA_scene_types.h"
45
46 #include "BLI_math.h"
47 #include "BLI_listbase.h"
48 #include "BLI_string.h"
49 #include "BLI_path_util.h"
50 #include "BLI_editVert.h"
51 #include "BLI_utildefines.h"
52
53 #include "BKE_curve.h"
54 #include "BKE_context.h"
55 #include "BKE_depsgraph.h"
56 #include "BKE_displist.h"
57 #include "BKE_DerivedMesh.h"
58 #include "BKE_effect.h"
59 #include "BKE_global.h"
60 #include "BKE_key.h"
61 #include "BKE_lattice.h"
62 #include "BKE_main.h"
63 #include "BKE_mesh.h"
64 #include "BKE_modifier.h"
65 #include "BKE_multires.h"
66 #include "BKE_report.h"
67 #include "BKE_object.h"
68 #include "BKE_particle.h"
69 #include "BKE_softbody.h"
70
71 #include "RNA_access.h"
72 #include "RNA_define.h"
73 #include "RNA_enum_types.h"
74
75 #include "ED_armature.h"
76 #include "ED_object.h"
77 #include "ED_screen.h"
78 #include "ED_mesh.h"
79
80 #include "WM_api.h"
81 #include "WM_types.h"
82
83 #include "object_intern.h"
84
85 /******************************** API ****************************/
86
87 ModifierData *ED_object_modifier_add(ReportList *reports, Main *bmain, Scene *scene, Object *ob, const char *name, int type)
88 {
89         ModifierData *md=NULL, *new_md=NULL;
90         ModifierTypeInfo *mti = modifierType_getInfo(type);
91         
92         /* only geometry objects should be able to get modifiers [#25291] */
93         if(!ELEM5(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_LATTICE)) {
94                 BKE_reportf(reports, RPT_WARNING, "Modifiers cannot be added to Object '%s'", ob->id.name+2);
95                 return NULL;
96         }
97         
98         if(mti->flags&eModifierTypeFlag_Single) {
99                 if(modifiers_findByType(ob, type)) {
100                         BKE_report(reports, RPT_WARNING, "Only one modifier of this type allowed.");
101                         return NULL;
102                 }
103         }
104         
105         if(type == eModifierType_ParticleSystem) {
106                 /* don't need to worry about the new modifier's name, since that is set to the number
107                  * of particle systems which shouldn't have too many duplicates 
108                  */
109                 new_md = object_add_particle_system(scene, ob, name);
110         }
111         else {
112                 /* get new modifier data to add */
113                 new_md= modifier_new(type);
114                 
115                 if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
116                         md = ob->modifiers.first;
117                         
118                         while(md && modifierType_getInfo(md->type)->type==eModifierTypeType_OnlyDeform)
119                                 md = md->next;
120                         
121                         BLI_insertlinkbefore(&ob->modifiers, md, new_md);
122                 }
123                 else
124                         BLI_addtail(&ob->modifiers, new_md);
125
126                 if(name)
127                         BLI_strncpy(new_md->name, name, sizeof(new_md->name));
128
129                 /* make sure modifier data has unique name */
130
131                 modifier_unique_name(&ob->modifiers, new_md);
132                 
133                 /* special cases */
134                 if(type == eModifierType_Softbody) {
135                         if(!ob->soft) {
136                                 ob->soft= sbNew(scene);
137                                 ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
138                         }
139                 }
140                 else if(type == eModifierType_Collision) {
141                         if(!ob->pd)
142                                 ob->pd= object_add_collision_fields(0);
143                         
144                         ob->pd->deflect= 1;
145                         DAG_scene_sort(bmain, scene);
146                 }
147                 else if(type == eModifierType_Surface)
148                         DAG_scene_sort(bmain, scene);
149                 else if(type == eModifierType_Multires)
150                         /* set totlvl from existing MDISPS layer if object already had it */
151                         multiresModifier_set_levels_from_disps((MultiresModifierData *)new_md, ob);
152         }
153
154         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
155
156         return new_md;
157 }
158
159 int ED_object_modifier_remove(ReportList *reports, Main *bmain, Scene *scene, Object *ob, ModifierData *md)
160 {
161         ModifierData *obmd;
162         int sort_depsgraph = 0;
163
164         /* It seems on rapid delete it is possible to
165          * get called twice on same modifier, so make
166          * sure it is in list. */
167         for(obmd=ob->modifiers.first; obmd; obmd=obmd->next)
168                 if(obmd==md)
169                         break;
170         
171         if(!obmd) {
172                 BKE_reportf(reports, RPT_ERROR, "Modifier '%s' not in object '%s'.", ob->id.name, md->name);
173                 return 0;
174         }
175
176         /* special cases */
177         if(md->type == eModifierType_ParticleSystem) {
178                 ParticleSystemModifierData *psmd=(ParticleSystemModifierData*)md;
179
180                 BLI_remlink(&ob->particlesystem, psmd->psys);
181                 psys_free(ob, psmd->psys);
182                 psmd->psys= NULL;
183         }
184         else if(md->type == eModifierType_Softbody) {
185                 if(ob->soft) {
186                         sbFree(ob->soft);
187                         ob->soft= NULL;
188                         ob->softflag= 0;
189                 }
190         }
191         else if(md->type == eModifierType_Collision) {
192                 if(ob->pd)
193                         ob->pd->deflect= 0;
194
195                 sort_depsgraph = 1;
196         }
197         else if(md->type == eModifierType_Surface) {
198                 if(ob->pd && ob->pd->shape == PFIELD_SHAPE_SURFACE)
199                         ob->pd->shape = PFIELD_SHAPE_PLANE;
200
201                 sort_depsgraph = 1;
202         }
203         else if(md->type == eModifierType_Smoke) {
204                 ob->dt = OB_TEXTURE;
205         }
206         else if(md->type == eModifierType_Multires) {
207                 int ok= 1;
208                 Mesh *me= ob->data;
209                 ModifierData *tmpmd;
210
211                 /* ensure MDISPS CustomData layer is't used by another multires modifiers */
212                 for(tmpmd= ob->modifiers.first; tmpmd; tmpmd= tmpmd->next)
213                         if(tmpmd!=md && tmpmd->type == eModifierType_Multires) {
214                                 ok= 0;
215                                 break;
216                         }
217
218                 if(ok) {
219                         if(me->edit_mesh) {
220                                 EditMesh *em= me->edit_mesh;
221                                 /* CustomData_external_remove is used here only to mark layer as non-external
222                                    for further free-ing, so zero element count looks safer than em->totface */
223                                 CustomData_external_remove(&em->fdata, &me->id, CD_MDISPS, 0);
224                                 EM_free_data_layer(em, &em->fdata, CD_MDISPS);
225                         } else {
226                                 CustomData_external_remove(&me->fdata, &me->id, CD_MDISPS, me->totface);
227                                 CustomData_free_layer_active(&me->fdata, CD_MDISPS, me->totface);
228                         }
229                 }
230         }
231
232         if(ELEM(md->type, eModifierType_Softbody, eModifierType_Cloth) &&
233                 ob->particlesystem.first == NULL) {
234                 ob->mode &= ~OB_MODE_PARTICLE_EDIT;
235         }
236
237         BLI_remlink(&ob->modifiers, md);
238         modifier_free(md);
239
240         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
241
242         /* sorting has to be done after the update so that dynamic systems can react properly */
243         if(sort_depsgraph)
244                 DAG_scene_sort(bmain, scene);
245
246         return 1;
247 }
248
249 int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
250 {
251         if(md->prev) {
252                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
253
254                 if(mti->type!=eModifierTypeType_OnlyDeform) {
255                         ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);
256
257                         if(nmti->flags&eModifierTypeFlag_RequiresOriginalData) {
258                                 BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data.");
259                                 return 0;
260                         }
261                 }
262
263                 BLI_remlink(&ob->modifiers, md);
264                 BLI_insertlink(&ob->modifiers, md->prev->prev, md);
265         }
266
267         return 1;
268 }
269
270 int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
271 {
272         if(md->next) {
273                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
274
275                 if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
276                         ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);
277
278                         if(nmti->type!=eModifierTypeType_OnlyDeform) {
279                                 BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier.");
280                                 return 0;
281                         }
282                 }
283
284                 BLI_remlink(&ob->modifiers, md);
285                 BLI_insertlink(&ob->modifiers, md->next, md);
286         }
287
288         return 1;
289 }
290
291 int ED_object_modifier_convert(ReportList *UNUSED(reports), Main *bmain, Scene *scene, Object *ob, ModifierData *md)
292 {
293         Object *obn;
294         ParticleSystem *psys;
295         ParticleCacheKey *key, **cache;
296         ParticleSettings *part;
297         Mesh *me;
298         MVert *mvert;
299         MEdge *medge;
300         int a, k, kmax;
301         int totvert=0, totedge=0, cvert=0;
302         int totpart=0, totchild=0;
303
304         if(md->type != eModifierType_ParticleSystem) return 0;
305         if(ob && ob->mode & OB_MODE_PARTICLE_EDIT) return 0;
306
307         psys=((ParticleSystemModifierData *)md)->psys;
308         part= psys->part;
309
310         if(part->ren_as != PART_DRAW_PATH || psys->pathcache == NULL)
311                 return 0;
312
313         totpart= psys->totcached;
314         totchild= psys->totchildcache;
315
316         if(totchild && (part->draw&PART_DRAW_PARENT)==0)
317                 totpart= 0;
318
319         /* count */
320         cache= psys->pathcache;
321         for(a=0; a<totpart; a++) {
322                 key= cache[a];
323
324                 if(key->steps > 0) {
325                         totvert+= key->steps+1;
326                         totedge+= key->steps;
327                 }
328         }
329
330         cache= psys->childcache;
331         for(a=0; a<totchild; a++) {
332                 key= cache[a];
333
334                 if(key->steps > 0) {
335                         totvert+= key->steps+1;
336                         totedge+= key->steps;
337                 }
338         }
339
340         if(totvert==0) return 0;
341
342         /* add new mesh */
343         obn= add_object(scene, OB_MESH);
344         me= obn->data;
345         
346         me->totvert= totvert;
347         me->totedge= totedge;
348         
349         me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
350         me->medge= CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
351         me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
352         
353         mvert= me->mvert;
354         medge= me->medge;
355
356         /* copy coordinates */
357         cache= psys->pathcache;
358         for(a=0; a<totpart; a++) {
359                 key= cache[a];
360                 kmax= key->steps;
361                 for(k=0; k<=kmax; k++,key++,cvert++,mvert++) {
362                         VECCOPY(mvert->co,key->co);
363                         if(k) {
364                                 medge->v1= cvert-1;
365                                 medge->v2= cvert;
366                                 medge->flag= ME_EDGEDRAW|ME_EDGERENDER|ME_LOOSEEDGE;
367                                 medge++;
368                         }
369                         else {
370                                 /* cheap trick to select the roots */
371                                 mvert->flag |= SELECT;
372                         }
373                 }
374         }
375
376         cache=psys->childcache;
377         for(a=0; a<totchild; a++) {
378                 key=cache[a];
379                 kmax=key->steps;
380                 for(k=0; k<=kmax; k++,key++,cvert++,mvert++) {
381                         VECCOPY(mvert->co,key->co);
382                         if(k) {
383                                 medge->v1=cvert-1;
384                                 medge->v2=cvert;
385                                 medge->flag= ME_EDGEDRAW|ME_EDGERENDER|ME_LOOSEEDGE;
386                                 medge++;
387                         }
388                         else {
389                                 /* cheap trick to select the roots */
390                                 mvert->flag |= SELECT;
391                         }
392                 }
393         }
394
395         DAG_scene_sort(bmain, scene);
396
397         return 1;
398 }
399
400 static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
401 {
402         ModifierTypeInfo *mti= modifierType_getInfo(md->type);
403
404         md->scene= scene;
405
406         if (mti->isDisabled && mti->isDisabled(md, 0)) {
407                 BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
408                 return 0;
409         }
410
411         if (ob->type==OB_MESH) {
412                 DerivedMesh *dm;
413                 Mesh *me= ob->data;
414                 Key *key=me->key;
415                 KeyBlock *kb;
416                 
417                 if(!modifier_sameTopology(md)) {
418                         BKE_report(reports, RPT_ERROR, "Only deforming modifiers can be applied to Shapes");
419                         return 0;
420                 }
421                 mesh_pmv_off(me);
422                 
423                 dm = mesh_create_derived_for_modifier(scene, ob, md);
424                 if (!dm) {
425                         BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
426                         return 0;
427                 }
428                 
429                 if(key == NULL) {
430                         key= me->key= add_key((ID *)me);
431                         key->type= KEY_RELATIVE;
432                         /* if that was the first key block added, then it was the basis.
433                          * Initialise it with the mesh, and add another for the modifier */
434                         kb= add_keyblock(key, NULL);
435                         mesh_to_key(me, kb);
436                 }
437
438                 kb= add_keyblock(key, md->name);
439                 DM_to_meshkey(dm, me, kb);
440                 
441                 dm->release(dm);
442         }
443         else {
444                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
445                 return 0;
446         }
447         return 1;
448 }
449
450 static int modifier_apply_obdata(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
451 {
452         ModifierTypeInfo *mti= modifierType_getInfo(md->type);
453
454         md->scene= scene;
455
456         if (mti->isDisabled && mti->isDisabled(md, 0)) {
457                 BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
458                 return 0;
459         }
460
461         if (ob->type==OB_MESH) {
462                 DerivedMesh *dm;
463                 Mesh *me = ob->data;
464                 MultiresModifierData *mmd= find_multires_modifier_before(scene, md);
465
466                 if( me->key) {
467                         BKE_report(reports, RPT_ERROR, "Modifier cannot be applied to Mesh with Shape Keys");
468                         return 0;
469                 }
470
471                 mesh_pmv_off(me);
472
473                 /* Multires: ensure that recent sculpting is applied */
474                 if(md->type == eModifierType_Multires)
475                         multires_force_update(ob);
476
477                 if (mmd && mmd->totlvl && mti->type==eModifierTypeType_OnlyDeform) {
478                         if(!multiresModifier_reshapeFromDeformMod (scene, mmd, ob, md)) {
479                                 BKE_report(reports, RPT_ERROR, "Multires modifier returned error, skipping apply");
480                                 return 0;
481                         }
482                 } else {
483                         dm = mesh_create_derived_for_modifier(scene, ob, md);
484                         if (!dm) {
485                                 BKE_report(reports, RPT_ERROR, "Modifier returned error, skipping apply");
486                                 return 0;
487                         }
488
489                         DM_to_mesh(dm, me);
490
491                         dm->release(dm);
492
493                         if(md->type == eModifierType_Multires) {
494                                 CustomData_external_remove(&me->fdata, &me->id, CD_MDISPS, me->totface);
495                                 CustomData_free_layer_active(&me->fdata, CD_MDISPS, me->totface);
496                         }
497                 }
498         }
499         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
500                 Curve *cu;
501                 int numVerts;
502                 float (*vertexCos)[3];
503
504                 if (mti->type==eModifierTypeType_Constructive) {
505                         BKE_report(reports, RPT_ERROR, "Cannot apply constructive modifiers on curve");
506                         return 0;
507                 }
508
509                 cu = ob->data;
510                 BKE_report(reports, RPT_INFO, "Applied modifier only changed CV points, not tesselated/bevel vertices");
511
512                 vertexCos = curve_getVertexCos(cu, &cu->nurb, &numVerts);
513                 mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0, 0);
514                 curve_applyVertexCos(cu, &cu->nurb, vertexCos);
515
516                 MEM_freeN(vertexCos);
517
518                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
519         }
520         else {
521                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
522                 return 0;
523         }
524
525         /* lattice modifier can be applied to particle system too */
526         if(ob->particlesystem.first) {
527
528                 ParticleSystem *psys = ob->particlesystem.first;
529
530                 for(; psys; psys=psys->next) {
531                         
532                         if(psys->part->type != PART_HAIR)
533                                 continue;
534
535                         psys_apply_hair_lattice(scene, ob, psys);
536                 }
537         }
538
539         return 1;
540 }
541
542 int ED_object_modifier_apply(ReportList *reports, Scene *scene, Object *ob, ModifierData *md, int mode)
543 {
544         int prev_mode;
545
546         if (scene->obedit) {
547                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied in editmode");
548                 return 0;
549         } else if (((ID*) ob->data)->us>1) {
550                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied to multi-user data");
551                 return 0;
552         }
553
554         if (md!=ob->modifiers.first)
555                 BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected.");
556
557         /* allow apply of a not-realtime modifier, by first re-enabling realtime. */
558         prev_mode= md->mode;
559         md->mode |= eModifierMode_Realtime;
560
561         if (mode == MODIFIER_APPLY_SHAPE) {
562                 if (!modifier_apply_shape(reports, scene, ob, md)) {
563                         md->mode= prev_mode;
564                         return 0;
565                 }
566         } else {
567                 if (!modifier_apply_obdata(reports, scene, ob, md)) {
568                         md->mode= prev_mode;
569                         return 0;
570                 }
571         }
572
573         BLI_remlink(&ob->modifiers, md);
574         modifier_free(md);
575
576         return 1;
577 }
578
579 int ED_object_modifier_copy(ReportList *UNUSED(reports), Object *ob, ModifierData *md)
580 {
581         ModifierData *nmd;
582         
583         nmd = modifier_new(md->type);
584         modifier_copyData(md, nmd);
585         BLI_insertlink(&ob->modifiers, md, nmd);
586         modifier_unique_name(&ob->modifiers, nmd);
587
588         return 1;
589 }
590
591 /************************ add modifier operator *********************/
592
593 static int modifier_add_exec(bContext *C, wmOperator *op)
594 {
595         Main *bmain= CTX_data_main(C);
596         Scene *scene= CTX_data_scene(C);
597         Object *ob = ED_object_active_context(C);
598         int type= RNA_enum_get(op->ptr, "type");
599
600         if(!ED_object_modifier_add(op->reports, bmain, scene, ob, NULL, type))
601                 return OPERATOR_CANCELLED;
602
603         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
604         
605         return OPERATOR_FINISHED;
606 }
607
608 static EnumPropertyItem *modifier_add_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
609 {       
610         Object *ob= ED_object_active_context(C);
611         EnumPropertyItem *item= NULL, *md_item;
612         ModifierTypeInfo *mti;
613         int totitem= 0, a;
614         
615         if(!ob)
616                 return modifier_type_items;
617
618         for(a=0; modifier_type_items[a].identifier; a++) {
619                 md_item= &modifier_type_items[a];
620
621                 if(md_item->identifier[0]) {
622                         mti= modifierType_getInfo(md_item->value);
623
624                         if(mti->flags & eModifierTypeFlag_NoUserAdd)
625                                 continue;
626
627                         if(!((mti->flags & eModifierTypeFlag_AcceptsCVs) ||
628                            (ob->type==OB_MESH && (mti->flags & eModifierTypeFlag_AcceptsMesh))))
629                                 continue;
630                 }
631
632                 RNA_enum_item_add(&item, &totitem, md_item);
633         }
634
635         RNA_enum_item_end(&item, &totitem);
636         *free= 1;
637
638         return item;
639 }
640
641 void OBJECT_OT_modifier_add(wmOperatorType *ot)
642 {
643         PropertyRNA *prop;
644
645         /* identifiers */
646         ot->name= "Add Modifier";
647         ot->description = "Add a modifier to the active object";
648         ot->idname= "OBJECT_OT_modifier_add";
649         
650         /* api callbacks */
651         ot->invoke= WM_menu_invoke;
652         ot->exec= modifier_add_exec;
653         ot->poll= ED_operator_object_active_editable;
654         
655         /* flags */
656         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
657         
658         /* properties */
659         prop= RNA_def_enum(ot->srna, "type", modifier_type_items, eModifierType_Subsurf, "Type", "");
660         RNA_def_enum_funcs(prop, modifier_add_itemf);
661         ot->prop= prop;
662 }
663
664 /************************ generic functions for operators using mod names and data context *********************/
665
666 static int edit_modifier_poll_generic(bContext *C, StructRNA *rna_type, int obtype_flag)
667 {
668         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", rna_type);
669         Object *ob= (ptr.id.data)?ptr.id.data:ED_object_active_context(C);
670         
671         if (!ob || ob->id.lib) return 0;
672         if (obtype_flag && ((1<<ob->type) & obtype_flag)==0) return 0;
673         if (ptr.id.data && ((ID*)ptr.id.data)->lib) return 0;
674         
675         return 1;
676 }
677
678 static int edit_modifier_poll(bContext *C)
679 {
680         return edit_modifier_poll_generic(C, &RNA_Modifier, 0);
681 }
682
683 static void edit_modifier_properties(wmOperatorType *ot)
684 {
685         RNA_def_string(ot->srna, "modifier", "", 32, "Modifier", "Name of the modifier to edit");
686 }
687
688 static int edit_modifier_invoke_properties(bContext *C, wmOperator *op)
689 {
690         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
691         ModifierData *md;
692         
693         if (RNA_property_is_set(op->ptr, "modifier"))
694                 return 1;
695         
696         if (ptr.data) {
697                 md = ptr.data;
698                 RNA_string_set(op->ptr, "modifier", md->name);
699                 return 1;
700         }
701         
702         return 0;
703 }
704
705 static ModifierData *edit_modifier_property_get(wmOperator *op, Object *ob, int type)
706 {
707         char modifier_name[32];
708         ModifierData *md;
709         RNA_string_get(op->ptr, "modifier", modifier_name);
710         
711         md = modifiers_findByName(ob, modifier_name);
712         
713         if (md && type != 0 && md->type != type)
714                 md = NULL;
715
716         return md;
717 }
718
719 /************************ remove modifier operator *********************/
720
721 static int modifier_remove_exec(bContext *C, wmOperator *op)
722 {
723         Main *bmain= CTX_data_main(C);
724         Scene *scene= CTX_data_scene(C);
725         Object *ob = ED_object_active_context(C);
726         ModifierData *md = edit_modifier_property_get(op, ob, 0);
727         int mode_orig = ob ? ob->mode : 0;
728         
729         if(!ob || !md || !ED_object_modifier_remove(op->reports, bmain, scene, ob, md))
730                 return OPERATOR_CANCELLED;
731
732         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
733
734         /* if cloth/softbody was removed, particle mode could be cleared */
735         if(mode_orig & OB_MODE_PARTICLE_EDIT)
736                 if((ob->mode & OB_MODE_PARTICLE_EDIT)==0)
737                         if(scene->basact && scene->basact->object==ob)
738                                 WM_event_add_notifier(C, NC_SCENE|ND_MODE|NS_MODE_OBJECT, NULL);
739         
740         return OPERATOR_FINISHED;
741 }
742
743 static int modifier_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
744 {
745         if (edit_modifier_invoke_properties(C, op))
746                 return modifier_remove_exec(C, op);
747         else
748                 return OPERATOR_CANCELLED;
749 }
750
751 void OBJECT_OT_modifier_remove(wmOperatorType *ot)
752 {
753         ot->name= "Remove Modifier";
754         ot->description= "Remove a modifier from the active object";
755         ot->idname= "OBJECT_OT_modifier_remove";
756
757         ot->invoke= modifier_remove_invoke;
758         ot->exec= modifier_remove_exec;
759         ot->poll= edit_modifier_poll;
760         
761         /* flags */
762         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
763         edit_modifier_properties(ot);
764 }
765
766 /************************ move up modifier operator *********************/
767
768 static int modifier_move_up_exec(bContext *C, wmOperator *op)
769 {
770         Object *ob = ED_object_active_context(C);
771         ModifierData *md = edit_modifier_property_get(op, ob, 0);
772
773         if(!ob || !md || !ED_object_modifier_move_up(op->reports, ob, md))
774                 return OPERATOR_CANCELLED;
775
776         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
777         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
778         
779         return OPERATOR_FINISHED;
780 }
781
782 static int modifier_move_up_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
783 {
784         if (edit_modifier_invoke_properties(C, op))
785                 return modifier_move_up_exec(C, op);
786         else
787                 return OPERATOR_CANCELLED;
788 }
789
790 void OBJECT_OT_modifier_move_up(wmOperatorType *ot)
791 {
792         ot->name= "Move Up Modifier";
793         ot->description= "Move modifier up in the stack";
794         ot->idname= "OBJECT_OT_modifier_move_up";
795
796         ot->invoke= modifier_move_up_invoke;
797         ot->exec= modifier_move_up_exec;
798         ot->poll= edit_modifier_poll;
799         
800         /* flags */
801         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
802         edit_modifier_properties(ot);
803 }
804
805 /************************ move down modifier operator *********************/
806
807 static int modifier_move_down_exec(bContext *C, wmOperator *op)
808 {
809         Object *ob = ED_object_active_context(C);
810         ModifierData *md = edit_modifier_property_get(op, ob, 0);
811
812         if(!ob || !md || !ED_object_modifier_move_down(op->reports, ob, md))
813                 return OPERATOR_CANCELLED;
814
815         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
816         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
817         
818         return OPERATOR_FINISHED;
819 }
820
821 static int modifier_move_down_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
822 {
823         if (edit_modifier_invoke_properties(C, op))
824                 return modifier_move_down_exec(C, op);
825         else
826                 return OPERATOR_CANCELLED;
827 }
828
829 void OBJECT_OT_modifier_move_down(wmOperatorType *ot)
830 {
831         ot->name= "Move Down Modifier";
832         ot->description= "Move modifier down in the stack";
833         ot->idname= "OBJECT_OT_modifier_move_down";
834
835         ot->invoke= modifier_move_down_invoke;
836         ot->exec= modifier_move_down_exec;
837         ot->poll= edit_modifier_poll;
838         
839         /* flags */
840         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
841         edit_modifier_properties(ot);
842 }
843
844 /************************ apply modifier operator *********************/
845
846 static int modifier_apply_exec(bContext *C, wmOperator *op)
847 {
848         Scene *scene= CTX_data_scene(C);
849         Object *ob = ED_object_active_context(C);
850         ModifierData *md = edit_modifier_property_get(op, ob, 0);
851         int apply_as= RNA_enum_get(op->ptr, "apply_as");
852         
853         if(!ob || !md || !ED_object_modifier_apply(op->reports, scene, ob, md, apply_as)) {
854                 return OPERATOR_CANCELLED;
855         }
856
857         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
858         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
859         
860         return OPERATOR_FINISHED;
861 }
862
863 static int modifier_apply_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
864 {
865         if (edit_modifier_invoke_properties(C, op))
866                 return modifier_apply_exec(C, op);
867         else
868                 return OPERATOR_CANCELLED;
869 }
870
871 static EnumPropertyItem modifier_apply_as_items[] = {
872         {MODIFIER_APPLY_DATA, "DATA", 0, "Object Data", "Apply modifier to the object's data"},
873         {MODIFIER_APPLY_SHAPE, "SHAPE", 0, "New Shape", "Apply deform-only modifier to a new shape on this object"},
874         {0, NULL, 0, NULL, NULL}};
875
876 void OBJECT_OT_modifier_apply(wmOperatorType *ot)
877 {
878         ot->name= "Apply Modifier";
879         ot->description= "Apply modifier and remove from the stack";
880         ot->idname= "OBJECT_OT_modifier_apply";
881
882         ot->invoke= modifier_apply_invoke;
883         ot->exec= modifier_apply_exec;
884         ot->poll= edit_modifier_poll;
885         
886         /* flags */
887         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
888         
889         RNA_def_enum(ot->srna, "apply_as", modifier_apply_as_items, MODIFIER_APPLY_DATA, "Apply as", "How to apply the modifier to the geometry");
890         edit_modifier_properties(ot);
891 }
892
893 /************************ convert modifier operator *********************/
894
895 static int modifier_convert_exec(bContext *C, wmOperator *op)
896 {
897         Main *bmain= CTX_data_main(C);
898         Scene *scene= CTX_data_scene(C);
899         Object *ob = ED_object_active_context(C);
900         ModifierData *md = edit_modifier_property_get(op, ob, 0);
901         
902         if(!ob || !md || !ED_object_modifier_convert(op->reports, bmain, scene, ob, md))
903                 return OPERATOR_CANCELLED;
904
905         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
906         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
907         
908         return OPERATOR_FINISHED;
909 }
910
911 static int modifier_convert_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
912 {
913         if (edit_modifier_invoke_properties(C, op))
914                 return modifier_convert_exec(C, op);
915         else
916                 return OPERATOR_CANCELLED;
917 }
918
919 void OBJECT_OT_modifier_convert(wmOperatorType *ot)
920 {
921         ot->name= "Convert Modifier";
922         ot->description= "Convert particles to a mesh object";
923         ot->idname= "OBJECT_OT_modifier_convert";
924
925         ot->invoke= modifier_convert_invoke;
926         ot->exec= modifier_convert_exec;
927         ot->poll= edit_modifier_poll;
928         
929         /* flags */
930         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
931         edit_modifier_properties(ot);
932 }
933
934 /************************ copy modifier operator *********************/
935
936 static int modifier_copy_exec(bContext *C, wmOperator *op)
937 {
938         Object *ob = ED_object_active_context(C);
939         ModifierData *md = edit_modifier_property_get(op, ob, 0);
940
941         if(!ob || !md || !ED_object_modifier_copy(op->reports, ob, md))
942                 return OPERATOR_CANCELLED;
943
944         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
945         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
946         
947         return OPERATOR_FINISHED;
948 }
949
950 static int modifier_copy_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
951 {
952         if (edit_modifier_invoke_properties(C, op))
953                 return modifier_copy_exec(C, op);
954         else
955                 return OPERATOR_CANCELLED;
956 }
957
958 void OBJECT_OT_modifier_copy(wmOperatorType *ot)
959 {
960         ot->name= "Copy Modifier";
961         ot->description= "Duplicate modifier at the same position in the stack";
962         ot->idname= "OBJECT_OT_modifier_copy";
963
964         ot->invoke= modifier_copy_invoke;
965         ot->exec= modifier_copy_exec;
966         ot->poll= edit_modifier_poll;
967         
968         /* flags */
969         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
970         edit_modifier_properties(ot);
971 }
972
973 /************* multires delete higher levels operator ****************/
974
975 static int multires_poll(bContext *C)
976 {
977         return edit_modifier_poll_generic(C, &RNA_MultiresModifier, (1<<OB_MESH));
978 }
979
980 static int multires_higher_levels_delete_exec(bContext *C, wmOperator *op)
981 {
982         Object *ob = ED_object_active_context(C);
983         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
984         
985         if (!mmd)
986                 return OPERATOR_CANCELLED;
987         
988         multiresModifier_del_levels(mmd, ob, 1);
989         
990         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
991         
992         return OPERATOR_FINISHED;
993 }
994
995 static int multires_higher_levels_delete_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
996 {
997         if (edit_modifier_invoke_properties(C, op))
998                 return multires_higher_levels_delete_exec(C, op);
999         else
1000                 return OPERATOR_CANCELLED;
1001 }
1002
1003 void OBJECT_OT_multires_higher_levels_delete(wmOperatorType *ot)
1004 {
1005         ot->name= "Delete Higher Levels";
1006         ot->description= "Deletes the higher resolution mesh, potential loss of detail";
1007         ot->idname= "OBJECT_OT_multires_higher_levels_delete";
1008
1009         ot->poll= multires_poll;
1010         ot->invoke= multires_higher_levels_delete_invoke;
1011         ot->exec= multires_higher_levels_delete_exec;
1012         
1013         /* flags */
1014         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1015         edit_modifier_properties(ot);
1016 }
1017
1018 /****************** multires subdivide operator *********************/
1019
1020 static int multires_subdivide_exec(bContext *C, wmOperator *op)
1021 {
1022         Object *ob = ED_object_active_context(C);
1023         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1024         
1025         if (!mmd)
1026                 return OPERATOR_CANCELLED;
1027         
1028         multiresModifier_subdivide(mmd, ob, 0, mmd->simple);
1029
1030         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1031         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1032         
1033         return OPERATOR_FINISHED;
1034 }
1035
1036 static int multires_subdivide_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1037 {
1038         if (edit_modifier_invoke_properties(C, op))
1039                 return multires_subdivide_exec(C, op);
1040         else
1041                 return OPERATOR_CANCELLED;
1042 }
1043
1044 void OBJECT_OT_multires_subdivide(wmOperatorType *ot)
1045 {
1046         ot->name= "Multires Subdivide";
1047         ot->description= "Add a new level of subdivision";
1048         ot->idname= "OBJECT_OT_multires_subdivide";
1049
1050         ot->poll= multires_poll;
1051         ot->invoke= multires_subdivide_invoke;
1052         ot->exec= multires_subdivide_exec;
1053         
1054         /* flags */
1055         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1056         edit_modifier_properties(ot);
1057 }
1058
1059 /****************** multires reshape operator *********************/
1060
1061 static int multires_reshape_exec(bContext *C, wmOperator *op)
1062 {
1063         Object *ob= ED_object_active_context(C), *secondob= NULL;
1064         Scene *scene= CTX_data_scene(C);
1065         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1066
1067         if (!mmd)
1068                 return OPERATOR_CANCELLED;
1069
1070         if(mmd->lvl==0) {
1071                 BKE_report(op->reports, RPT_ERROR, "Reshape can work only with higher levels of subdivisions.");
1072                 return OPERATOR_CANCELLED;
1073         }
1074
1075         CTX_DATA_BEGIN(C, Object*, selob, selected_editable_objects) {
1076                 if(selob->type == OB_MESH && selob != ob) {
1077                         secondob= selob;
1078                         break;
1079                 }
1080         }
1081         CTX_DATA_END;
1082
1083         if(!secondob) {
1084                 BKE_report(op->reports, RPT_ERROR, "Second selected mesh object require to copy shape from.");
1085                 return OPERATOR_CANCELLED;
1086         }
1087
1088         if(!multiresModifier_reshape(scene, mmd, ob, secondob)) {
1089                 BKE_report(op->reports, RPT_ERROR, "Objects do not have the same number of vertices.");
1090                 return OPERATOR_CANCELLED;
1091         }
1092
1093         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1094         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1095
1096         return OPERATOR_FINISHED;
1097 }
1098
1099 static int multires_reshape_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1100 {
1101         if (edit_modifier_invoke_properties(C, op))
1102                 return multires_reshape_exec(C, op);
1103         else
1104                 return OPERATOR_CANCELLED;
1105 }
1106
1107 void OBJECT_OT_multires_reshape(wmOperatorType *ot)
1108 {
1109         ot->name= "Multires Reshape";
1110         ot->description= "Copy vertex coordinates from other object";
1111         ot->idname= "OBJECT_OT_multires_reshape";
1112
1113         ot->poll= multires_poll;
1114         ot->invoke= multires_reshape_invoke;
1115         ot->exec= multires_reshape_exec;
1116         
1117         /* flags */
1118         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1119         edit_modifier_properties(ot);
1120 }
1121
1122 /****************** multires save external operator *********************/
1123
1124 static int multires_external_save_exec(bContext *C, wmOperator *op)
1125 {
1126         Object *ob = ED_object_active_context(C);
1127         Mesh *me= (ob)? ob->data: op->customdata;
1128         char path[FILE_MAX];
1129         int relative= RNA_boolean_get(op->ptr, "relative_path");
1130
1131         if(!me)
1132                 return OPERATOR_CANCELLED;
1133
1134         if(CustomData_external_test(&me->fdata, CD_MDISPS))
1135                 return OPERATOR_CANCELLED;
1136         
1137         RNA_string_get(op->ptr, "filepath", path);
1138
1139         if(relative)
1140                 BLI_path_rel(path, G.main->name);
1141
1142         CustomData_external_add(&me->fdata, &me->id, CD_MDISPS, me->totface, path);
1143         CustomData_external_write(&me->fdata, &me->id, CD_MASK_MESH, me->totface, 0);
1144         
1145         return OPERATOR_FINISHED;
1146 }
1147
1148 static int multires_external_save_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1149 {
1150         Object *ob = ED_object_active_context(C);
1151         MultiresModifierData *mmd;
1152         Mesh *me= ob->data;
1153         char path[FILE_MAX];
1154
1155         if (!edit_modifier_invoke_properties(C, op))
1156                 return OPERATOR_CANCELLED;
1157         
1158         mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1159         
1160         if (!mmd)
1161                 return OPERATOR_CANCELLED;
1162         
1163         if(CustomData_external_test(&me->fdata, CD_MDISPS))
1164                 return OPERATOR_CANCELLED;
1165
1166         if(!RNA_property_is_set(op->ptr, "relative_path"))
1167                 RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
1168
1169         if(RNA_property_is_set(op->ptr, "filepath"))
1170                 return multires_external_save_exec(C, op);
1171         
1172         op->customdata= me;
1173
1174         BLI_snprintf(path, sizeof(path), "//%s.btx", me->id.name+2);
1175         RNA_string_set(op->ptr, "filepath", path);
1176         
1177         WM_event_add_fileselect(C, op);
1178
1179         return OPERATOR_RUNNING_MODAL;
1180 }
1181
1182 void OBJECT_OT_multires_external_save(wmOperatorType *ot)
1183 {
1184         ot->name= "Multires Save External";
1185         ot->description= "Save displacements to an external file";
1186         ot->idname= "OBJECT_OT_multires_external_save";
1187
1188         // XXX modifier no longer in context after file browser .. ot->poll= multires_poll;
1189         ot->exec= multires_external_save_exec;
1190         ot->invoke= multires_external_save_invoke;
1191         ot->poll= multires_poll;
1192         
1193         /* flags */
1194         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1195
1196         WM_operator_properties_filesel(ot, FOLDERFILE|BTXFILE, FILE_SPECIAL, FILE_SAVE, WM_FILESEL_FILEPATH|WM_FILESEL_RELPATH);
1197         edit_modifier_properties(ot);
1198 }
1199
1200 /****************** multires pack operator *********************/
1201
1202 static int multires_external_pack_exec(bContext *C, wmOperator *UNUSED(op))
1203 {
1204         Object *ob = ED_object_active_context(C);
1205         Mesh *me= ob->data;
1206
1207         if(!CustomData_external_test(&me->fdata, CD_MDISPS))
1208                 return OPERATOR_CANCELLED;
1209
1210         // XXX don't remove..
1211         CustomData_external_remove(&me->fdata, &me->id, CD_MDISPS, me->totface);
1212         
1213         return OPERATOR_FINISHED;
1214 }
1215
1216 void OBJECT_OT_multires_external_pack(wmOperatorType *ot)
1217 {
1218         ot->name= "Multires Pack External";
1219         ot->description= "Pack displacements from an external file";
1220         ot->idname= "OBJECT_OT_multires_external_pack";
1221
1222         ot->poll= multires_poll;
1223         ot->exec= multires_external_pack_exec;
1224         
1225         /* flags */
1226         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1227 }
1228
1229 /********************* multires apply base ***********************/
1230 static int multires_base_apply_exec(bContext *C, wmOperator *op)
1231 {
1232         Object *ob = ED_object_active_context(C);
1233         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1234         
1235         if (!mmd)
1236                 return OPERATOR_CANCELLED;
1237         
1238         multiresModifier_base_apply(mmd, ob);
1239
1240         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1241         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1242         
1243         return OPERATOR_FINISHED;
1244 }
1245
1246 static int multires_base_apply_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1247 {
1248         if (edit_modifier_invoke_properties(C, op))
1249                 return multires_base_apply_exec(C, op);
1250         else
1251                 return OPERATOR_CANCELLED;
1252 }
1253
1254
1255 void OBJECT_OT_multires_base_apply(wmOperatorType *ot)
1256 {
1257         ot->name= "Multires Apply Base";
1258         ot->description= "Modify the base mesh to conform to the displaced mesh";
1259         ot->idname= "OBJECT_OT_multires_base_apply";
1260
1261         ot->poll= multires_poll;
1262         ot->invoke= multires_base_apply_invoke;
1263         ot->exec= multires_base_apply_exec;
1264         
1265         /* flags */
1266         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1267         edit_modifier_properties(ot);
1268 }
1269
1270
1271 /************************ mdef bind operator *********************/
1272
1273 static int meshdeform_poll(bContext *C)
1274 {
1275         return edit_modifier_poll_generic(C, &RNA_MeshDeformModifier, (1<<OB_MESH));
1276 }
1277
1278 static int meshdeform_bind_exec(bContext *C, wmOperator *op)
1279 {
1280         Scene *scene= CTX_data_scene(C);
1281         Object *ob = ED_object_active_context(C);
1282         MeshDeformModifierData *mmd = (MeshDeformModifierData *)edit_modifier_property_get(op, ob, eModifierType_MeshDeform);
1283         
1284         if (!mmd)
1285                 return OPERATOR_CANCELLED;
1286
1287         if(mmd->bindcagecos) {
1288                 MEM_freeN(mmd->bindcagecos);
1289                 if(mmd->dyngrid) MEM_freeN(mmd->dyngrid);
1290                 if(mmd->dyninfluences) MEM_freeN(mmd->dyninfluences);
1291                 if(mmd->bindinfluences) MEM_freeN(mmd->bindinfluences);
1292                 if(mmd->bindoffsets) MEM_freeN(mmd->bindoffsets);
1293                 if(mmd->dynverts) MEM_freeN(mmd->dynverts);
1294                 if(mmd->bindweights) MEM_freeN(mmd->bindweights); /* deprecated */
1295                 if(mmd->bindcos) MEM_freeN(mmd->bindcos); /* deprecated */
1296
1297                 mmd->bindcagecos= NULL;
1298                 mmd->dyngrid= NULL;
1299                 mmd->dyninfluences= NULL;
1300                 mmd->bindoffsets= NULL;
1301                 mmd->dynverts= NULL;
1302                 mmd->bindweights= NULL; /* deprecated */
1303                 mmd->bindcos= NULL; /* deprecated */
1304                 mmd->totvert= 0;
1305                 mmd->totcagevert= 0;
1306                 mmd->totinfluence= 0;
1307                 
1308                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1309                 WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1310         }
1311         else {
1312                 DerivedMesh *dm;
1313                 int mode= mmd->modifier.mode;
1314
1315                 /* force modifier to run, it will call binding routine */
1316                 mmd->bindfunc= mesh_deform_bind;
1317                 mmd->modifier.mode |= eModifierMode_Realtime;
1318
1319                 if(ob->type == OB_MESH) {
1320                         dm= mesh_create_derived_view(scene, ob, 0);
1321                         dm->release(dm);
1322                 }
1323                 else if(ob->type == OB_LATTICE) {
1324                         lattice_calc_modifiers(scene, ob);
1325                 }
1326                 else if(ob->type==OB_MBALL) {
1327                         makeDispListMBall(scene, ob);
1328                 }
1329                 else if(ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
1330                         makeDispListCurveTypes(scene, ob, 0);
1331                 }
1332
1333                 mmd->bindfunc= NULL;
1334                 mmd->modifier.mode= mode;
1335         }
1336         
1337         return OPERATOR_FINISHED;
1338 }
1339
1340 static int meshdeform_bind_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1341 {
1342         if (edit_modifier_invoke_properties(C, op))
1343                 return meshdeform_bind_exec(C, op);
1344         else 
1345                 return OPERATOR_CANCELLED;
1346 }
1347
1348 void OBJECT_OT_meshdeform_bind(wmOperatorType *ot)
1349 {
1350         /* identifiers */
1351         ot->name= "Mesh Deform Bind";
1352         ot->description = "Bind mesh to cage in mesh deform modifier";
1353         ot->idname= "OBJECT_OT_meshdeform_bind";
1354         
1355         /* api callbacks */
1356         ot->poll= meshdeform_poll;
1357         ot->invoke= meshdeform_bind_invoke;
1358         ot->exec= meshdeform_bind_exec;
1359         
1360         /* flags */
1361         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1362         edit_modifier_properties(ot);
1363 }
1364
1365 /****************** explode refresh operator *********************/
1366
1367 static int explode_poll(bContext *C)
1368 {
1369         return edit_modifier_poll_generic(C, &RNA_ExplodeModifier, 0);
1370 }
1371
1372 static int explode_refresh_exec(bContext *C, wmOperator *op)
1373 {
1374         Object *ob = ED_object_active_context(C);
1375         ExplodeModifierData *emd = (ExplodeModifierData *)edit_modifier_property_get(op, ob, eModifierType_Explode);
1376         
1377         if (!emd)
1378                 return OPERATOR_CANCELLED;
1379
1380         emd->flag |= eExplodeFlag_CalcFaces;
1381
1382         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1383         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1384         
1385         return OPERATOR_FINISHED;
1386 }
1387
1388 static int explode_refresh_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
1389 {
1390         if (edit_modifier_invoke_properties(C, op))
1391                 return explode_refresh_exec(C, op);
1392         else
1393                 return OPERATOR_CANCELLED;
1394 }
1395
1396
1397 void OBJECT_OT_explode_refresh(wmOperatorType *ot)
1398 {
1399         ot->name= "Explode Refresh";
1400         ot->description= "Refresh data in the Explode modifier";
1401         ot->idname= "OBJECT_OT_explode_refresh";
1402
1403         ot->poll= explode_poll;
1404         ot->invoke= explode_refresh_invoke;
1405         ot->exec= explode_refresh_exec;
1406         
1407         /* flags */
1408         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1409         edit_modifier_properties(ot);
1410 }
1411