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