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