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