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