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