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