ce9693793a4652b96981e01bb92f33beefe14255
[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_armature_types.h"
39 #include "DNA_curve_types.h"
40 #include "DNA_key_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_meshdata_types.h"
43 #include "DNA_object_force.h"
44 #include "DNA_scene_types.h"
45
46 #include "BLI_bitmap.h"
47 #include "BLI_math.h"
48 #include "BLI_listbase.h"
49 #include "BLI_string.h"
50 #include "BLI_string_utf8.h"
51 #include "BLI_path_util.h"
52 #include "BLI_utildefines.h"
53
54 #include "BKE_animsys.h"
55 #include "BKE_curve.h"
56 #include "BKE_context.h"
57 #include "BKE_depsgraph.h"
58 #include "BKE_displist.h"
59 #include "BKE_DerivedMesh.h"
60 #include "BKE_effect.h"
61 #include "BKE_global.h"
62 #include "BKE_key.h"
63 #include "BKE_lattice.h"
64 #include "BKE_main.h"
65 #include "BKE_mesh.h"
66 #include "BKE_mesh_mapping.h"
67 #include "BKE_modifier.h"
68 #include "BKE_multires.h"
69 #include "BKE_report.h"
70 #include "BKE_object.h"
71 #include "BKE_object_deform.h"
72 #include "BKE_ocean.h"
73 #include "BKE_paint.h"
74 #include "BKE_particle.h"
75 #include "BKE_softbody.h"
76 #include "BKE_editmesh.h"
77
78 #include "RNA_access.h"
79 #include "RNA_define.h"
80 #include "RNA_enum_types.h"
81
82 #include "ED_armature.h"
83 #include "ED_object.h"
84 #include "ED_screen.h"
85 #include "ED_mesh.h"
86
87 #include "WM_api.h"
88 #include "WM_types.h"
89
90 #include "object_intern.h"
91
92 static void modifier_skin_customdata_delete(struct Object *ob);
93
94 /******************************** API ****************************/
95
96 ModifierData *ED_object_modifier_add(ReportList *reports, Main *bmain, Scene *scene, Object *ob, const char *name, int type)
97 {
98         ModifierData *md = NULL, *new_md = NULL;
99         const ModifierTypeInfo *mti = modifierType_getInfo(type);
100         
101         /* only geometry objects should be able to get modifiers [#25291] */
102         if (!ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_LATTICE)) {
103                 BKE_reportf(reports, RPT_WARNING, "Modifiers cannot be added to object '%s'", ob->id.name + 2);
104                 return NULL;
105         }
106         
107         if (mti->flags & eModifierTypeFlag_Single) {
108                 if (modifiers_findByType(ob, type)) {
109                         BKE_report(reports, RPT_WARNING, "Only one modifier of this type is allowed");
110                         return NULL;
111                 }
112         }
113         
114         if (type == eModifierType_ParticleSystem) {
115                 /* don't need to worry about the new modifier's name, since that is set to the number
116                  * of particle systems which shouldn't have too many duplicates 
117                  */
118                 new_md = object_add_particle_system(scene, ob, name);
119         }
120         else {
121                 /* get new modifier data to add */
122                 new_md = modifier_new(type);
123                 
124                 if (mti->flags & eModifierTypeFlag_RequiresOriginalData) {
125                         md = ob->modifiers.first;
126                         
127                         while (md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
128                                 md = md->next;
129                         
130                         BLI_insertlinkbefore(&ob->modifiers, md, new_md);
131                 }
132                 else
133                         BLI_addtail(&ob->modifiers, new_md);
134
135                 if (name) {
136                         BLI_strncpy_utf8(new_md->name, name, sizeof(new_md->name));
137                 }
138
139                 /* make sure modifier data has unique name */
140
141                 modifier_unique_name(&ob->modifiers, new_md);
142                 
143                 /* special cases */
144                 if (type == eModifierType_Softbody) {
145                         if (!ob->soft) {
146                                 ob->soft = sbNew(scene);
147                                 ob->softflag |= OB_SB_GOAL | OB_SB_EDGES;
148                         }
149                 }
150                 else if (type == eModifierType_Collision) {
151                         if (!ob->pd)
152                                 ob->pd = object_add_collision_fields(0);
153                         
154                         ob->pd->deflect = 1;
155                 }
156                 else if (type == eModifierType_Surface) {
157                         /* pass */
158                 }
159                 else if (type == eModifierType_Multires) {
160                         /* set totlvl from existing MDISPS layer if object already had it */
161                         multiresModifier_set_levels_from_disps((MultiresModifierData *)new_md, ob);
162
163                         if (ob->mode & OB_MODE_SCULPT) {
164                                 /* ensure that grid paint mask layer is created */
165                                 BKE_sculpt_mask_layers_ensure(ob, (MultiresModifierData *)new_md);
166                         }
167                 }
168                 else if (type == eModifierType_Skin) {
169                         /* ensure skin-node customdata exists */
170                         BKE_mesh_ensure_skin_customdata(ob->data);
171                 }
172         }
173
174         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
175         DAG_relations_tag_update(bmain);
176
177         return new_md;
178 }
179
180 /* Return true if the object has a modifier of type 'type' other than
181  * the modifier pointed to be 'exclude', otherwise returns false. */
182 static bool object_has_modifier(const Object *ob, const ModifierData *exclude,
183                                 ModifierType type)
184 {
185         ModifierData *md;
186
187         for (md = ob->modifiers.first; md; md = md->next) {
188                 if ((md != exclude) && (md->type == type))
189                         return true;
190         }
191
192         return false;
193 }
194
195 /* If the object data of 'orig_ob' has other users, run 'callback' on
196  * each of them.
197  *
198  * If include_orig is true, the callback will run on 'orig_ob' too.
199  * 
200  * If the callback ever returns true, iteration will stop and the
201  * function value will be true. Otherwise the function returns false.
202  */
203 bool ED_object_iter_other(Main *bmain, Object *orig_ob, const bool include_orig,
204                           bool (*callback)(Object *ob, void *callback_data),
205                           void *callback_data)
206 {
207         ID *ob_data_id = orig_ob->data;
208         int users = ob_data_id->us;
209
210         if (ob_data_id->flag & LIB_FAKEUSER)
211                 users--;
212
213         /* First check that the object's data has multiple users */
214         if (users > 1) {
215                 Object *ob;
216                 int totfound = include_orig ? 0 : 1;
217
218                 for (ob = bmain->object.first; ob && totfound < users;
219                      ob = ob->id.next)
220                 {
221                         if (((ob != orig_ob) || include_orig) &&
222                             (ob->data == orig_ob->data))
223                         {
224                                 if (callback(ob, callback_data))
225                                         return true;
226
227                                 totfound++;
228                         }
229                 }
230         }
231         else if (include_orig) {
232                 return callback(orig_ob, callback_data);
233         }
234
235         return false;
236 }
237
238 static bool object_has_modifier_cb(Object *ob, void *data)
239 {
240         ModifierType type = *((ModifierType *)data);
241
242         return object_has_modifier(ob, NULL, type);
243 }
244
245 /* Use with ED_object_iter_other(). Sets the total number of levels
246  * for any multires modifiers on the object to the int pointed to by
247  * callback_data. */
248 bool ED_object_multires_update_totlevels_cb(Object *ob, void *totlevel_v)
249 {
250         ModifierData *md;
251         int totlevel = *((char *)totlevel_v);
252
253         for (md = ob->modifiers.first; md; md = md->next) {
254                 if (md->type == eModifierType_Multires) {
255                         multires_set_tot_level(ob, (MultiresModifierData *)md, totlevel);
256                         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
257                 }
258         }
259         return false;
260 }
261
262 /* Return true if no modifier of type 'type' other than 'exclude' */
263 static bool object_modifier_safe_to_delete(Main *bmain, Object *ob,
264                                            ModifierData *exclude,
265                                            ModifierType type)
266 {
267         return (!object_has_modifier(ob, exclude, type) &&
268                 !ED_object_iter_other(bmain, ob, false,
269                                       object_has_modifier_cb, &type));
270 }
271
272 static bool object_modifier_remove(Main *bmain, Object *ob, ModifierData *md,
273                                    bool *r_sort_depsgraph)
274 {
275         /* It seems on rapid delete it is possible to
276          * get called twice on same modifier, so make
277          * sure it is in list. */
278         if (BLI_findindex(&ob->modifiers, md) == -1) {
279                 return 0;
280         }
281
282         /* special cases */
283         if (md->type == eModifierType_ParticleSystem) {
284                 ParticleSystemModifierData *psmd = (ParticleSystemModifierData *)md;
285
286                 BLI_remlink(&ob->particlesystem, psmd->psys);
287                 psys_free(ob, psmd->psys);
288                 psmd->psys = NULL;
289         }
290         else if (md->type == eModifierType_Softbody) {
291                 if (ob->soft) {
292                         sbFree(ob->soft);
293                         ob->soft = NULL;
294                         ob->softflag = 0;
295                 }
296         }
297         else if (md->type == eModifierType_Collision) {
298                 if (ob->pd)
299                         ob->pd->deflect = 0;
300
301                 *r_sort_depsgraph = true;
302         }
303         else if (md->type == eModifierType_Surface) {
304                 *r_sort_depsgraph = true;
305         }
306         else if (md->type == eModifierType_Multires) {
307                 /* Delete MDisps layer if not used by another multires modifier */
308                 if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_Multires))
309                         multires_customdata_delete(ob->data);
310         }
311         else if (md->type == eModifierType_Skin) {
312                 /* Delete MVertSkin layer if not used by another skin modifier */
313                 if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_Skin))
314                         modifier_skin_customdata_delete(ob);
315         }
316
317         if (ELEM(md->type, eModifierType_Softbody, eModifierType_Cloth) &&
318             BLI_listbase_is_empty(&ob->particlesystem))
319         {
320                 ob->mode &= ~OB_MODE_PARTICLE_EDIT;
321         }
322
323         DAG_relations_tag_update(bmain);
324
325         BLI_remlink(&ob->modifiers, md);
326         modifier_free(md);
327
328         return 1;
329 }
330
331 bool ED_object_modifier_remove(ReportList *reports, Main *bmain, Object *ob, ModifierData *md)
332 {
333         bool sort_depsgraph = false;
334         bool ok;
335
336         ok = object_modifier_remove(bmain, ob, md, &sort_depsgraph);
337
338         if (!ok) {
339                 BKE_reportf(reports, RPT_ERROR, "Modifier '%s' not in object '%s'", md->name, ob->id.name);
340                 return 0;
341         }
342
343         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
344         DAG_relations_tag_update(bmain);
345
346         return 1;
347 }
348
349 void ED_object_modifier_clear(Main *bmain, Object *ob)
350 {
351         ModifierData *md = ob->modifiers.first;
352         bool sort_depsgraph = false;
353
354         if (!md)
355                 return;
356
357         while (md) {
358                 ModifierData *next_md;
359
360                 next_md = md->next;
361
362                 object_modifier_remove(bmain, ob, md, &sort_depsgraph);
363
364                 md = next_md;
365         }
366
367         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
368         DAG_relations_tag_update(bmain);
369 }
370
371 int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
372 {
373         if (md->prev) {
374                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
375
376                 if (mti->type != eModifierTypeType_OnlyDeform) {
377                         const ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);
378
379                         if (nmti->flags & eModifierTypeFlag_RequiresOriginalData) {
380                                 BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data");
381                                 return 0;
382                         }
383                 }
384
385                 BLI_remlink(&ob->modifiers, md);
386                 BLI_insertlinkbefore(&ob->modifiers, md->prev, md);
387         }
388
389         return 1;
390 }
391
392 int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
393 {
394         if (md->next) {
395                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
396
397                 if (mti->flags & eModifierTypeFlag_RequiresOriginalData) {
398                         const ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);
399
400                         if (nmti->type != eModifierTypeType_OnlyDeform) {
401                                 BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier");
402                                 return 0;
403                         }
404                 }
405
406                 BLI_remlink(&ob->modifiers, md);
407                 BLI_insertlinkafter(&ob->modifiers, md->next, md);
408         }
409
410         return 1;
411 }
412
413 int ED_object_modifier_convert(ReportList *UNUSED(reports), Main *bmain, Scene *scene, Object *ob, ModifierData *md)
414 {
415         Object *obn;
416         ParticleSystem *psys;
417         ParticleCacheKey *key, **cache;
418         ParticleSettings *part;
419         Mesh *me;
420         MVert *mvert;
421         MEdge *medge;
422         int a, k, kmax;
423         int totvert = 0, totedge = 0, cvert = 0;
424         int totpart = 0, totchild = 0;
425
426         if (md->type != eModifierType_ParticleSystem) return 0;
427         if (ob && ob->mode & OB_MODE_PARTICLE_EDIT) return 0;
428
429         psys = ((ParticleSystemModifierData *)md)->psys;
430         part = psys->part;
431
432         if (part->ren_as != PART_DRAW_PATH || psys->pathcache == NULL)
433                 return 0;
434
435         totpart = psys->totcached;
436         totchild = psys->totchildcache;
437
438         if (totchild && (part->draw & PART_DRAW_PARENT) == 0)
439                 totpart = 0;
440
441         /* count */
442         cache = psys->pathcache;
443         for (a = 0; a < totpart; a++) {
444                 key = cache[a];
445
446                 if (key->segments > 0) {
447                         totvert += key->segments + 1;
448                         totedge += key->segments;
449                 }
450         }
451
452         cache = psys->childcache;
453         for (a = 0; a < totchild; a++) {
454                 key = cache[a];
455
456                 if (key->segments > 0) {
457                         totvert += key->segments + 1;
458                         totedge += key->segments;
459                 }
460         }
461
462         if (totvert == 0) return 0;
463
464         /* add new mesh */
465         obn = BKE_object_add(bmain, scene, OB_MESH, NULL);
466         me = obn->data;
467         
468         me->totvert = totvert;
469         me->totedge = totedge;
470         
471         me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
472         me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
473         me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
474         
475         mvert = me->mvert;
476         medge = me->medge;
477
478         /* copy coordinates */
479         cache = psys->pathcache;
480         for (a = 0; a < totpart; a++) {
481                 key = cache[a];
482                 kmax = key->segments;
483                 for (k = 0; k <= kmax; k++, key++, cvert++, mvert++) {
484                         copy_v3_v3(mvert->co, key->co);
485                         if (k) {
486                                 medge->v1 = cvert - 1;
487                                 medge->v2 = cvert;
488                                 medge->flag = ME_EDGEDRAW | ME_EDGERENDER | ME_LOOSEEDGE;
489                                 medge++;
490                         }
491                         else {
492                                 /* cheap trick to select the roots */
493                                 mvert->flag |= SELECT;
494                         }
495                 }
496         }
497
498         cache = psys->childcache;
499         for (a = 0; a < totchild; a++) {
500                 key = cache[a];
501                 kmax = key->segments;
502                 for (k = 0; k <= kmax; k++, key++, cvert++, mvert++) {
503                         copy_v3_v3(mvert->co, key->co);
504                         if (k) {
505                                 medge->v1 = cvert - 1;
506                                 medge->v2 = cvert;
507                                 medge->flag = ME_EDGEDRAW | ME_EDGERENDER | ME_LOOSEEDGE;
508                                 medge++;
509                         }
510                         else {
511                                 /* cheap trick to select the roots */
512                                 mvert->flag |= SELECT;
513                         }
514                 }
515         }
516
517         DAG_relations_tag_update(bmain);
518
519         return 1;
520 }
521
522 static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
523 {
524         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
525
526         md->scene = scene;
527
528         if (mti->isDisabled && mti->isDisabled(md, 0)) {
529                 BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
530                 return 0;
531         }
532
533         /*
534          * It should be ridiculously easy to extract the original verts that we want
535          * and form the shape data.  We can probably use the CD KEYINDEX layer (or
536          * whatever I ended up calling it, too tired to check now), though this would
537          * by necessity have to make some potentially ugly assumptions about the order
538          * of the mesh data :-/  you can probably assume in 99% of cases that the first
539          * element of a given index is the original, and any subsequent duplicates are
540          * copies/interpolates, but that's an assumption that would need to be tested
541          * and then predominantly stated in comments in a half dozen headers.
542          */
543
544         if (ob->type == OB_MESH) {
545                 DerivedMesh *dm;
546                 Mesh *me = ob->data;
547                 Key *key = me->key;
548                 KeyBlock *kb;
549                 
550                 if (!modifier_isSameTopology(md) || mti->type == eModifierTypeType_NonGeometrical) {
551                         BKE_report(reports, RPT_ERROR, "Only deforming modifiers can be applied to shapes");
552                         return 0;
553                 }
554                 
555                 dm = mesh_create_derived_for_modifier(scene, ob, md, 0);
556                 if (!dm) {
557                         BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
558                         return 0;
559                 }
560                 
561                 if (key == NULL) {
562                         key = me->key = BKE_key_add((ID *)me);
563                         key->type = KEY_RELATIVE;
564                         /* if that was the first key block added, then it was the basis.
565                          * Initialize it with the mesh, and add another for the modifier */
566                         kb = BKE_keyblock_add(key, NULL);
567                         BKE_keyblock_convert_from_mesh(me, kb);
568                 }
569
570                 kb = BKE_keyblock_add(key, md->name);
571                 DM_to_meshkey(dm, me, kb);
572                 
573                 dm->release(dm);
574         }
575         else {
576                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
577                 return 0;
578         }
579         return 1;
580 }
581
582 static int modifier_apply_obdata(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
583 {
584         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
585
586         md->scene = scene;
587
588         if (mti->isDisabled && mti->isDisabled(md, 0)) {
589                 BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
590                 return 0;
591         }
592
593         if (ob->type == OB_MESH) {
594                 DerivedMesh *dm;
595                 Mesh *me = ob->data;
596                 MultiresModifierData *mmd = find_multires_modifier_before(scene, md);
597
598                 if (me->key && mti->type != eModifierTypeType_NonGeometrical) {
599                         BKE_report(reports, RPT_ERROR, "Modifier cannot be applied to a mesh with shape keys");
600                         return 0;
601                 }
602
603                 /* Multires: ensure that recent sculpting is applied */
604                 if (md->type == eModifierType_Multires)
605                         multires_force_update(ob);
606
607                 if (mmd && mmd->totlvl && mti->type == eModifierTypeType_OnlyDeform) {
608                         if (!multiresModifier_reshapeFromDeformMod(scene, mmd, ob, md)) {
609                                 BKE_report(reports, RPT_ERROR, "Multires modifier returned error, skipping apply");
610                                 return 0;
611                         }
612                 }
613                 else {
614                         dm = mesh_create_derived_for_modifier(scene, ob, md, 1);
615                         if (!dm) {
616                                 BKE_report(reports, RPT_ERROR, "Modifier returned error, skipping apply");
617                                 return 0;
618                         }
619
620                         DM_to_mesh(dm, me, ob, CD_MASK_MESH, true);
621
622                         if (md->type == eModifierType_Multires)
623                                 multires_customdata_delete(me);
624                 }
625         }
626         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
627                 Curve *cu;
628                 int numVerts;
629                 float (*vertexCos)[3];
630
631                 if (ELEM(mti->type, eModifierTypeType_Constructive, eModifierTypeType_Nonconstructive)) {
632                         BKE_report(reports, RPT_ERROR, "Cannot apply constructive modifiers on curve");
633                         return 0;
634                 }
635
636                 cu = ob->data;
637                 BKE_report(reports, RPT_INFO, "Applied modifier only changed CV points, not tessellated/bevel vertices");
638
639                 vertexCos = BKE_curve_nurbs_vertexCos_get(&cu->nurb, &numVerts);
640                 mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0);
641                 BK_curve_nurbs_vertexCos_apply(&cu->nurb, vertexCos);
642
643                 MEM_freeN(vertexCos);
644
645                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
646         }
647         else {
648                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
649                 return 0;
650         }
651
652         /* lattice modifier can be applied to particle system too */
653         if (ob->particlesystem.first) {
654
655                 ParticleSystem *psys = ob->particlesystem.first;
656
657                 for (; psys; psys = psys->next) {
658                         
659                         if (psys->part->type != PART_HAIR)
660                                 continue;
661
662                         psys_apply_hair_lattice(scene, ob, psys);
663                 }
664         }
665
666         return 1;
667 }
668
669 int ED_object_modifier_apply(ReportList *reports, Scene *scene, Object *ob, ModifierData *md, int mode)
670 {
671         int prev_mode;
672
673         if (scene->obedit) {
674                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied in edit mode");
675                 return 0;
676         }
677         else if (((ID *) ob->data)->us > 1) {
678                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied to multi-user data");
679                 return 0;
680         }
681         else if ((ob->mode & OB_MODE_SCULPT) &&
682                  (find_multires_modifier_before(scene, md)) &&
683                  (modifier_isSameTopology(md) == false))
684         {
685                 BKE_report(reports, RPT_ERROR, "Constructive modifier cannot be applied to multi-res data in sculpt mode");
686                 return 0;
687         }
688
689         if (md != ob->modifiers.first)
690                 BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected");
691
692         /* allow apply of a not-realtime modifier, by first re-enabling realtime. */
693         prev_mode = md->mode;
694         md->mode |= eModifierMode_Realtime;
695
696         if (mode == MODIFIER_APPLY_SHAPE) {
697                 if (!modifier_apply_shape(reports, scene, ob, md)) {
698                         md->mode = prev_mode;
699                         return 0;
700                 }
701         }
702         else {
703                 if (!modifier_apply_obdata(reports, scene, ob, md)) {
704                         md->mode = prev_mode;
705                         return 0;
706                 }
707         }
708
709         BLI_remlink(&ob->modifiers, md);
710         modifier_free(md);
711
712         return 1;
713 }
714
715 int ED_object_modifier_copy(ReportList *UNUSED(reports), Object *ob, ModifierData *md)
716 {
717         ModifierData *nmd;
718         
719         nmd = modifier_new(md->type);
720         modifier_copyData(md, nmd);
721         BLI_insertlinkafter(&ob->modifiers, md, nmd);
722         modifier_unique_name(&ob->modifiers, nmd);
723
724         return 1;
725 }
726
727 /************************ add modifier operator *********************/
728
729 static int modifier_add_exec(bContext *C, wmOperator *op)
730 {
731         Main *bmain = CTX_data_main(C);
732         Scene *scene = CTX_data_scene(C);
733         Object *ob = ED_object_active_context(C);
734         int type = RNA_enum_get(op->ptr, "type");
735
736         if (!ED_object_modifier_add(op->reports, bmain, scene, ob, NULL, type))
737                 return OPERATOR_CANCELLED;
738
739         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
740         
741         return OPERATOR_FINISHED;
742 }
743
744 static EnumPropertyItem *modifier_add_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
745 {       
746         Object *ob = ED_object_active_context(C);
747         EnumPropertyItem *item = NULL, *md_item, *group_item = NULL;
748         const ModifierTypeInfo *mti;
749         int totitem = 0, a;
750         
751         if (!ob)
752                 return modifier_type_items;
753
754         for (a = 0; modifier_type_items[a].identifier; a++) {
755                 md_item = &modifier_type_items[a];
756
757                 if (md_item->identifier[0]) {
758                         mti = modifierType_getInfo(md_item->value);
759
760                         if (mti->flags & eModifierTypeFlag_NoUserAdd)
761                                 continue;
762
763                         if (!BKE_object_support_modifier_type_check(ob, md_item->value))
764                                 continue;
765                 }
766                 else {
767                         group_item = md_item;
768                         md_item = NULL;
769
770                         continue;
771                 }
772
773                 if (group_item) {
774                         RNA_enum_item_add(&item, &totitem, group_item);
775                         group_item = NULL;
776                 }
777
778                 RNA_enum_item_add(&item, &totitem, md_item);
779         }
780
781         RNA_enum_item_end(&item, &totitem);
782         *r_free = true;
783
784         return item;
785 }
786
787 void OBJECT_OT_modifier_add(wmOperatorType *ot)
788 {
789         PropertyRNA *prop;
790
791         /* identifiers */
792         ot->name = "Add Modifier";
793         ot->description = "Add a modifier to the active object";
794         ot->idname = "OBJECT_OT_modifier_add";
795         
796         /* api callbacks */
797         ot->invoke = WM_menu_invoke;
798         ot->exec = modifier_add_exec;
799         ot->poll = ED_operator_object_active_editable;
800         
801         /* flags */
802         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
803         
804         /* properties */
805         prop = RNA_def_enum(ot->srna, "type", modifier_type_items, eModifierType_Subsurf, "Type", "");
806         RNA_def_enum_funcs(prop, modifier_add_itemf);
807         ot->prop = prop;
808 }
809
810 /************************ generic functions for operators using mod names and data context *********************/
811
812 int edit_modifier_poll_generic(bContext *C, StructRNA *rna_type, int obtype_flag)
813 {
814         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", rna_type);
815         Object *ob = (ptr.id.data) ? ptr.id.data : ED_object_active_context(C);
816         
817         if (!ob || ob->id.lib) return 0;
818         if (obtype_flag && ((1 << ob->type) & obtype_flag) == 0) return 0;
819         if (ptr.id.data && ((ID *)ptr.id.data)->lib) return 0;
820         
821         return 1;
822 }
823
824 int edit_modifier_poll(bContext *C)
825 {
826         return edit_modifier_poll_generic(C, &RNA_Modifier, 0);
827 }
828
829 void edit_modifier_properties(wmOperatorType *ot)
830 {
831         RNA_def_string(ot->srna, "modifier", NULL, MAX_NAME, "Modifier", "Name of the modifier to edit");
832 }
833
834 int edit_modifier_invoke_properties(bContext *C, wmOperator *op)
835 {
836         ModifierData *md;
837         
838         if (RNA_struct_property_is_set(op->ptr, "modifier")) {
839                 return true;
840         }
841         else {
842                 PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
843                 if (ptr.data) {
844                         md = ptr.data;
845                         RNA_string_set(op->ptr, "modifier", md->name);
846                         return true;
847                 }
848         }
849
850         return false;
851 }
852
853 ModifierData *edit_modifier_property_get(wmOperator *op, Object *ob, int type)
854 {
855         char modifier_name[MAX_NAME];
856         ModifierData *md;
857         RNA_string_get(op->ptr, "modifier", modifier_name);
858         
859         md = modifiers_findByName(ob, modifier_name);
860         
861         if (md && type != 0 && md->type != type)
862                 md = NULL;
863
864         return md;
865 }
866
867 /************************ remove modifier operator *********************/
868
869 static int modifier_remove_exec(bContext *C, wmOperator *op)
870 {
871         Main *bmain = CTX_data_main(C);
872         Scene *scene = CTX_data_scene(C);
873         Object *ob = ED_object_active_context(C);
874         ModifierData *md = edit_modifier_property_get(op, ob, 0);
875         int mode_orig = ob->mode;
876         
877         if (!md || !ED_object_modifier_remove(op->reports, bmain, ob, md))
878                 return OPERATOR_CANCELLED;
879
880         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
881
882         /* if cloth/softbody was removed, particle mode could be cleared */
883         if (mode_orig & OB_MODE_PARTICLE_EDIT)
884                 if ((ob->mode & OB_MODE_PARTICLE_EDIT) == 0)
885                         if (scene->basact && scene->basact->object == ob)
886                                 WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
887         
888         return OPERATOR_FINISHED;
889 }
890
891 static int modifier_remove_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
892 {
893         if (edit_modifier_invoke_properties(C, op))
894                 return modifier_remove_exec(C, op);
895         else
896                 return OPERATOR_CANCELLED;
897 }
898
899 void OBJECT_OT_modifier_remove(wmOperatorType *ot)
900 {
901         ot->name = "Remove Modifier";
902         ot->description = "Remove a modifier from the active object";
903         ot->idname = "OBJECT_OT_modifier_remove";
904
905         ot->invoke = modifier_remove_invoke;
906         ot->exec = modifier_remove_exec;
907         ot->poll = edit_modifier_poll;
908         
909         /* flags */
910         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
911         edit_modifier_properties(ot);
912 }
913
914 /************************ move up modifier operator *********************/
915
916 static int modifier_move_up_exec(bContext *C, wmOperator *op)
917 {
918         Object *ob = ED_object_active_context(C);
919         ModifierData *md = edit_modifier_property_get(op, ob, 0);
920
921         if (!md || !ED_object_modifier_move_up(op->reports, ob, md))
922                 return OPERATOR_CANCELLED;
923
924         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
925         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
926         
927         return OPERATOR_FINISHED;
928 }
929
930 static int modifier_move_up_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
931 {
932         if (edit_modifier_invoke_properties(C, op))
933                 return modifier_move_up_exec(C, op);
934         else
935                 return OPERATOR_CANCELLED;
936 }
937
938 void OBJECT_OT_modifier_move_up(wmOperatorType *ot)
939 {
940         ot->name = "Move Up Modifier";
941         ot->description = "Move modifier up in the stack";
942         ot->idname = "OBJECT_OT_modifier_move_up";
943
944         ot->invoke = modifier_move_up_invoke;
945         ot->exec = modifier_move_up_exec;
946         ot->poll = edit_modifier_poll;
947         
948         /* flags */
949         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
950         edit_modifier_properties(ot);
951 }
952
953 /************************ move down modifier operator *********************/
954
955 static int modifier_move_down_exec(bContext *C, wmOperator *op)
956 {
957         Object *ob = ED_object_active_context(C);
958         ModifierData *md = edit_modifier_property_get(op, ob, 0);
959
960         if (!md || !ED_object_modifier_move_down(op->reports, ob, md))
961                 return OPERATOR_CANCELLED;
962
963         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
964         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
965         
966         return OPERATOR_FINISHED;
967 }
968
969 static int modifier_move_down_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
970 {
971         if (edit_modifier_invoke_properties(C, op))
972                 return modifier_move_down_exec(C, op);
973         else
974                 return OPERATOR_CANCELLED;
975 }
976
977 void OBJECT_OT_modifier_move_down(wmOperatorType *ot)
978 {
979         ot->name = "Move Down Modifier";
980         ot->description = "Move modifier down in the stack";
981         ot->idname = "OBJECT_OT_modifier_move_down";
982
983         ot->invoke = modifier_move_down_invoke;
984         ot->exec = modifier_move_down_exec;
985         ot->poll = edit_modifier_poll;
986         
987         /* flags */
988         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
989         edit_modifier_properties(ot);
990 }
991
992 /************************ apply modifier operator *********************/
993
994 static int modifier_apply_exec(bContext *C, wmOperator *op)
995 {
996         Scene *scene = CTX_data_scene(C);
997         Object *ob = ED_object_active_context(C);
998         ModifierData *md = edit_modifier_property_get(op, ob, 0);
999         int apply_as = RNA_enum_get(op->ptr, "apply_as");
1000
1001         if (!md || !ED_object_modifier_apply(op->reports, scene, ob, md, apply_as)) {
1002                 return OPERATOR_CANCELLED;
1003         }
1004
1005         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1006         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1007         
1008         return OPERATOR_FINISHED;
1009 }
1010
1011 static int modifier_apply_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1012 {
1013         if (edit_modifier_invoke_properties(C, op))
1014                 return modifier_apply_exec(C, op);
1015         else
1016                 return OPERATOR_CANCELLED;
1017 }
1018
1019 static EnumPropertyItem modifier_apply_as_items[] = {
1020         {MODIFIER_APPLY_DATA, "DATA", 0, "Object Data", "Apply modifier to the object's data"},
1021         {MODIFIER_APPLY_SHAPE, "SHAPE", 0, "New Shape", "Apply deform-only modifier to a new shape on this object"},
1022         {0, NULL, 0, NULL, NULL}
1023 };
1024
1025 void OBJECT_OT_modifier_apply(wmOperatorType *ot)
1026 {
1027         ot->name = "Apply Modifier";
1028         ot->description = "Apply modifier and remove from the stack";
1029         ot->idname = "OBJECT_OT_modifier_apply";
1030
1031         ot->invoke = modifier_apply_invoke;
1032         ot->exec = modifier_apply_exec;
1033         ot->poll = edit_modifier_poll;
1034         
1035         /* flags */
1036         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1037         
1038         RNA_def_enum(ot->srna, "apply_as", modifier_apply_as_items, MODIFIER_APPLY_DATA, "Apply as", "How to apply the modifier to the geometry");
1039         edit_modifier_properties(ot);
1040 }
1041
1042 /************************ convert modifier operator *********************/
1043
1044 static int modifier_convert_exec(bContext *C, wmOperator *op)
1045 {
1046         Main *bmain = CTX_data_main(C);
1047         Scene *scene = CTX_data_scene(C);
1048         Object *ob = ED_object_active_context(C);
1049         ModifierData *md = edit_modifier_property_get(op, ob, 0);
1050         
1051         if (!md || !ED_object_modifier_convert(op->reports, bmain, scene, ob, md))
1052                 return OPERATOR_CANCELLED;
1053
1054         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1055         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1056         
1057         return OPERATOR_FINISHED;
1058 }
1059
1060 static int modifier_convert_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1061 {
1062         if (edit_modifier_invoke_properties(C, op))
1063                 return modifier_convert_exec(C, op);
1064         else
1065                 return OPERATOR_CANCELLED;
1066 }
1067
1068 void OBJECT_OT_modifier_convert(wmOperatorType *ot)
1069 {
1070         ot->name = "Convert Modifier";
1071         ot->description = "Convert particles to a mesh object";
1072         ot->idname = "OBJECT_OT_modifier_convert";
1073
1074         ot->invoke = modifier_convert_invoke;
1075         ot->exec = modifier_convert_exec;
1076         ot->poll = edit_modifier_poll;
1077         
1078         /* flags */
1079         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1080         edit_modifier_properties(ot);
1081 }
1082
1083 /************************ copy modifier operator *********************/
1084
1085 static int modifier_copy_exec(bContext *C, wmOperator *op)
1086 {
1087         Object *ob = ED_object_active_context(C);
1088         ModifierData *md = edit_modifier_property_get(op, ob, 0);
1089
1090         if (!md || !ED_object_modifier_copy(op->reports, ob, md))
1091                 return OPERATOR_CANCELLED;
1092
1093         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1094         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1095         
1096         return OPERATOR_FINISHED;
1097 }
1098
1099 static int modifier_copy_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1100 {
1101         if (edit_modifier_invoke_properties(C, op))
1102                 return modifier_copy_exec(C, op);
1103         else
1104                 return OPERATOR_CANCELLED;
1105 }
1106
1107 void OBJECT_OT_modifier_copy(wmOperatorType *ot)
1108 {
1109         ot->name = "Copy Modifier";
1110         ot->description = "Duplicate modifier at the same position in the stack";
1111         ot->idname = "OBJECT_OT_modifier_copy";
1112
1113         ot->invoke = modifier_copy_invoke;
1114         ot->exec = modifier_copy_exec;
1115         ot->poll = edit_modifier_poll;
1116         
1117         /* flags */
1118         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1119         edit_modifier_properties(ot);
1120 }
1121
1122 /************* multires delete higher levels operator ****************/
1123
1124 static int multires_poll(bContext *C)
1125 {
1126         return edit_modifier_poll_generic(C, &RNA_MultiresModifier, (1 << OB_MESH));
1127 }
1128
1129 static int multires_higher_levels_delete_exec(bContext *C, wmOperator *op)
1130 {
1131         Object *ob = ED_object_active_context(C);
1132         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1133         
1134         if (!mmd)
1135                 return OPERATOR_CANCELLED;
1136         
1137         multiresModifier_del_levels(mmd, ob, 1);
1138
1139         ED_object_iter_other(CTX_data_main(C), ob, true,
1140                              ED_object_multires_update_totlevels_cb,
1141                              &mmd->totlvl);
1142         
1143         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1144         
1145         return OPERATOR_FINISHED;
1146 }
1147
1148 static int multires_higher_levels_delete_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1149 {
1150         if (edit_modifier_invoke_properties(C, op))
1151                 return multires_higher_levels_delete_exec(C, op);
1152         else
1153                 return OPERATOR_CANCELLED;
1154 }
1155
1156 void OBJECT_OT_multires_higher_levels_delete(wmOperatorType *ot)
1157 {
1158         ot->name = "Delete Higher Levels";
1159         ot->description = "Deletes the higher resolution mesh, potential loss of detail";
1160         ot->idname = "OBJECT_OT_multires_higher_levels_delete";
1161
1162         ot->poll = multires_poll;
1163         ot->invoke = multires_higher_levels_delete_invoke;
1164         ot->exec = multires_higher_levels_delete_exec;
1165         
1166         /* flags */
1167         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1168         edit_modifier_properties(ot);
1169 }
1170
1171 /****************** multires subdivide operator *********************/
1172
1173 static int multires_subdivide_exec(bContext *C, wmOperator *op)
1174 {
1175         Object *ob = ED_object_active_context(C);
1176         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1177         
1178         if (!mmd)
1179                 return OPERATOR_CANCELLED;
1180         
1181         multiresModifier_subdivide(mmd, ob, 0, mmd->simple);
1182
1183         ED_object_iter_other(CTX_data_main(C), ob, true,
1184                              ED_object_multires_update_totlevels_cb,
1185                              &mmd->totlvl);
1186
1187         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1188         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1189
1190         if (ob->mode & OB_MODE_SCULPT) {
1191                 /* ensure that grid paint mask layer is created */
1192                 BKE_sculpt_mask_layers_ensure(ob, mmd);
1193         }
1194         
1195         return OPERATOR_FINISHED;
1196 }
1197
1198 static int multires_subdivide_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1199 {
1200         if (edit_modifier_invoke_properties(C, op))
1201                 return multires_subdivide_exec(C, op);
1202         else
1203                 return OPERATOR_CANCELLED;
1204 }
1205
1206 void OBJECT_OT_multires_subdivide(wmOperatorType *ot)
1207 {
1208         ot->name = "Multires Subdivide";
1209         ot->description = "Add a new level of subdivision";
1210         ot->idname = "OBJECT_OT_multires_subdivide";
1211
1212         ot->poll = multires_poll;
1213         ot->invoke = multires_subdivide_invoke;
1214         ot->exec = multires_subdivide_exec;
1215         
1216         /* flags */
1217         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1218         edit_modifier_properties(ot);
1219 }
1220
1221 /****************** multires reshape operator *********************/
1222
1223 static int multires_reshape_exec(bContext *C, wmOperator *op)
1224 {
1225         Object *ob = ED_object_active_context(C), *secondob = NULL;
1226         Scene *scene = CTX_data_scene(C);
1227         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1228
1229         if (!mmd)
1230                 return OPERATOR_CANCELLED;
1231
1232         if (mmd->lvl == 0) {
1233                 BKE_report(op->reports, RPT_ERROR, "Reshape can work only with higher levels of subdivisions");
1234                 return OPERATOR_CANCELLED;
1235         }
1236
1237         CTX_DATA_BEGIN(C, Object *, selob, selected_editable_objects)
1238         {
1239                 if (selob->type == OB_MESH && selob != ob) {
1240                         secondob = selob;
1241                         break;
1242                 }
1243         }
1244         CTX_DATA_END;
1245
1246         if (!secondob) {
1247                 BKE_report(op->reports, RPT_ERROR, "Second selected mesh object required to copy shape from");
1248                 return OPERATOR_CANCELLED;
1249         }
1250
1251         if (!multiresModifier_reshape(scene, mmd, ob, secondob)) {
1252                 BKE_report(op->reports, RPT_ERROR, "Objects do not have the same number of vertices");
1253                 return OPERATOR_CANCELLED;
1254         }
1255
1256         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1257         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1258
1259         return OPERATOR_FINISHED;
1260 }
1261
1262 static int multires_reshape_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1263 {
1264         if (edit_modifier_invoke_properties(C, op))
1265                 return multires_reshape_exec(C, op);
1266         else
1267                 return OPERATOR_CANCELLED;
1268 }
1269
1270 void OBJECT_OT_multires_reshape(wmOperatorType *ot)
1271 {
1272         ot->name = "Multires Reshape";
1273         ot->description = "Copy vertex coordinates from other object";
1274         ot->idname = "OBJECT_OT_multires_reshape";
1275
1276         ot->poll = multires_poll;
1277         ot->invoke = multires_reshape_invoke;
1278         ot->exec = multires_reshape_exec;
1279         
1280         /* flags */
1281         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1282         edit_modifier_properties(ot);
1283 }
1284
1285
1286                 
1287 /****************** multires save external operator *********************/
1288
1289 static int multires_external_save_exec(bContext *C, wmOperator *op)
1290 {
1291         Object *ob = ED_object_active_context(C);
1292         Mesh *me = (ob) ? ob->data : op->customdata;
1293         char path[FILE_MAX];
1294         const bool relative = RNA_boolean_get(op->ptr, "relative_path");
1295
1296         if (!me)
1297                 return OPERATOR_CANCELLED;
1298
1299         if (CustomData_external_test(&me->ldata, CD_MDISPS))
1300                 return OPERATOR_CANCELLED;
1301         
1302         RNA_string_get(op->ptr, "filepath", path);
1303
1304         if (relative)
1305                 BLI_path_rel(path, G.main->name);
1306
1307         CustomData_external_add(&me->ldata, &me->id, CD_MDISPS, me->totloop, path);
1308         CustomData_external_write(&me->ldata, &me->id, CD_MASK_MESH, me->totloop, 0);
1309         
1310         return OPERATOR_FINISHED;
1311 }
1312
1313 static int multires_external_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1314 {
1315         Object *ob = ED_object_active_context(C);
1316         MultiresModifierData *mmd;
1317         Mesh *me = ob->data;
1318         char path[FILE_MAX];
1319
1320         if (!edit_modifier_invoke_properties(C, op))
1321                 return OPERATOR_CANCELLED;
1322         
1323         mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1324         
1325         if (!mmd)
1326                 return OPERATOR_CANCELLED;
1327         
1328         if (CustomData_external_test(&me->ldata, CD_MDISPS))
1329                 return OPERATOR_CANCELLED;
1330
1331         if (RNA_struct_property_is_set(op->ptr, "filepath"))
1332                 return multires_external_save_exec(C, op);
1333         
1334         op->customdata = me;
1335
1336         BLI_snprintf(path, sizeof(path), "//%s.btx", me->id.name + 2);
1337         RNA_string_set(op->ptr, "filepath", path);
1338         
1339         WM_event_add_fileselect(C, op);
1340
1341         return OPERATOR_RUNNING_MODAL;
1342 }
1343
1344 void OBJECT_OT_multires_external_save(wmOperatorType *ot)
1345 {
1346         ot->name = "Multires Save External";
1347         ot->description = "Save displacements to an external file";
1348         ot->idname = "OBJECT_OT_multires_external_save";
1349
1350         /* XXX modifier no longer in context after file browser .. ot->poll = multires_poll; */
1351         ot->exec = multires_external_save_exec;
1352         ot->invoke = multires_external_save_invoke;
1353         ot->poll = multires_poll;
1354         
1355         /* flags */
1356         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1357
1358         WM_operator_properties_filesel(ot, FILE_TYPE_FOLDER | FILE_TYPE_BTX, FILE_SPECIAL, FILE_SAVE,
1359                                        WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH, FILE_DEFAULTDISPLAY);
1360         edit_modifier_properties(ot);
1361 }
1362
1363 /****************** multires pack operator *********************/
1364
1365 static int multires_external_pack_exec(bContext *C, wmOperator *UNUSED(op))
1366 {
1367         Object *ob = ED_object_active_context(C);
1368         Mesh *me = ob->data;
1369
1370         if (!CustomData_external_test(&me->ldata, CD_MDISPS))
1371                 return OPERATOR_CANCELLED;
1372
1373         /* XXX don't remove.. */
1374         CustomData_external_remove(&me->ldata, &me->id, CD_MDISPS, me->totloop);
1375         
1376         return OPERATOR_FINISHED;
1377 }
1378
1379 void OBJECT_OT_multires_external_pack(wmOperatorType *ot)
1380 {
1381         ot->name = "Multires Pack External";
1382         ot->description = "Pack displacements from an external file";
1383         ot->idname = "OBJECT_OT_multires_external_pack";
1384
1385         ot->poll = multires_poll;
1386         ot->exec = multires_external_pack_exec;
1387         
1388         /* flags */
1389         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1390 }
1391
1392 /********************* multires apply base ***********************/
1393 static int multires_base_apply_exec(bContext *C, wmOperator *op)
1394 {
1395         Object *ob = ED_object_active_context(C);
1396         MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(op, ob, eModifierType_Multires);
1397         
1398         if (!mmd)
1399                 return OPERATOR_CANCELLED;
1400         
1401         multiresModifier_base_apply(mmd, ob);
1402
1403         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1404         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1405         
1406         return OPERATOR_FINISHED;
1407 }
1408
1409 static int multires_base_apply_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1410 {
1411         if (edit_modifier_invoke_properties(C, op))
1412                 return multires_base_apply_exec(C, op);
1413         else
1414                 return OPERATOR_CANCELLED;
1415 }
1416
1417
1418 void OBJECT_OT_multires_base_apply(wmOperatorType *ot)
1419 {
1420         ot->name = "Multires Apply Base";
1421         ot->description = "Modify the base mesh to conform to the displaced mesh";
1422         ot->idname = "OBJECT_OT_multires_base_apply";
1423
1424         ot->poll = multires_poll;
1425         ot->invoke = multires_base_apply_invoke;
1426         ot->exec = multires_base_apply_exec;
1427         
1428         /* flags */
1429         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1430         edit_modifier_properties(ot);
1431 }
1432
1433
1434 /************************** skin modifier ***********************/
1435
1436 static void modifier_skin_customdata_delete(Object *ob)
1437 {
1438         Mesh *me = ob->data;
1439         BMEditMesh *em = me->edit_btmesh;
1440         
1441         if (em)
1442                 BM_data_layer_free(em->bm, &em->bm->vdata, CD_MVERT_SKIN);
1443         else
1444                 CustomData_free_layer_active(&me->vdata, CD_MVERT_SKIN, me->totvert);
1445 }
1446
1447 static int skin_poll(bContext *C)
1448 {
1449         return (!CTX_data_edit_object(C) &&
1450                 edit_modifier_poll_generic(C, &RNA_SkinModifier, (1 << OB_MESH)));
1451 }
1452
1453 static int skin_edit_poll(bContext *C)
1454 {
1455         return (CTX_data_edit_object(C) &&
1456                 edit_modifier_poll_generic(C, &RNA_SkinModifier, (1 << OB_MESH)));
1457 }
1458
1459 static void skin_root_clear(BMesh *bm, BMVert *bm_vert, GSet *visited)
1460 {
1461         BMEdge *bm_edge;
1462         BMIter bm_iter;
1463         
1464         BM_ITER_ELEM (bm_edge, &bm_iter, bm_vert, BM_EDGES_OF_VERT) {
1465                 BMVert *v2 = BM_edge_other_vert(bm_edge, bm_vert);
1466
1467                 if (!BLI_gset_haskey(visited, v2)) {
1468                         MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
1469                                                              v2->head.data,
1470                                                              CD_MVERT_SKIN);
1471
1472                         /* clear vertex root flag and add to visited set */
1473                         vs->flag &= ~MVERT_SKIN_ROOT;
1474                         BLI_gset_insert(visited, v2);
1475
1476                         skin_root_clear(bm, v2, visited);
1477                 }
1478         }
1479 }
1480
1481 static int skin_root_mark_exec(bContext *C, wmOperator *UNUSED(op))
1482 {
1483         Object *ob = CTX_data_edit_object(C);
1484         BMEditMesh *em = BKE_editmesh_from_object(ob);
1485         BMesh *bm = em->bm;
1486         BMVert *bm_vert;
1487         BMIter bm_iter;
1488         GSet *visited;
1489
1490         visited = BLI_gset_ptr_new(__func__);
1491
1492         BKE_mesh_ensure_skin_customdata(ob->data);
1493
1494         BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
1495                 if (!BLI_gset_haskey(visited, bm_vert) &&
1496                     BM_elem_flag_test(bm_vert, BM_ELEM_SELECT))
1497                 {
1498                         MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
1499                                                              bm_vert->head.data,
1500                                                              CD_MVERT_SKIN);
1501
1502                         /* mark vertex as root and add to visited set */
1503                         vs->flag |= MVERT_SKIN_ROOT;
1504                         BLI_gset_insert(visited, bm_vert);
1505
1506                         /* clear root flag from all connected vertices (recursively) */
1507                         skin_root_clear(bm, bm_vert, visited);
1508                 }
1509         }
1510
1511         BLI_gset_free(visited, NULL);
1512
1513         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1514         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1515         
1516         return OPERATOR_FINISHED;
1517 }
1518
1519 void OBJECT_OT_skin_root_mark(wmOperatorType *ot)
1520 {
1521         ot->name = "Skin Root Mark";
1522         ot->description = "Mark selected vertices as roots";
1523         ot->idname = "OBJECT_OT_skin_root_mark";
1524
1525         ot->poll = skin_edit_poll;
1526         ot->exec = skin_root_mark_exec;
1527         
1528         /* flags */
1529         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1530 }
1531
1532 typedef enum {
1533         SKIN_LOOSE_MARK,
1534         SKIN_LOOSE_CLEAR
1535 } SkinLooseAction;
1536
1537 static int skin_loose_mark_clear_exec(bContext *C, wmOperator *op)
1538 {
1539         Object *ob = CTX_data_edit_object(C);
1540         BMEditMesh *em = BKE_editmesh_from_object(ob);
1541         BMesh *bm = em->bm;
1542         BMVert *bm_vert;
1543         BMIter bm_iter;
1544         SkinLooseAction action = RNA_enum_get(op->ptr, "action");
1545
1546         if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
1547                 return OPERATOR_CANCELLED;
1548         }
1549
1550         BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
1551                 if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
1552                         MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
1553                                                              bm_vert->head.data,
1554                                                              CD_MVERT_SKIN);
1555
1556
1557                         switch (action) {
1558                                 case SKIN_LOOSE_MARK:
1559                                         vs->flag |= MVERT_SKIN_LOOSE;
1560                                         break;
1561                                 case SKIN_LOOSE_CLEAR:
1562                                         vs->flag &= ~MVERT_SKIN_LOOSE;
1563                                         break;
1564                         }
1565                 }
1566         }
1567
1568         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1569         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1570         
1571         return OPERATOR_FINISHED;
1572 }
1573
1574 void OBJECT_OT_skin_loose_mark_clear(wmOperatorType *ot)
1575 {
1576         static EnumPropertyItem action_items[] = {
1577                 {SKIN_LOOSE_MARK, "MARK", 0, "Mark", "Mark selected vertices as loose"},
1578                 {SKIN_LOOSE_CLEAR, "CLEAR", 0, "Clear", "Set selected vertices as not loose"},
1579                 {0, NULL, 0, NULL, NULL}
1580         };
1581
1582         ot->name = "Skin Mark/Clear Loose";
1583         ot->description = "Mark/clear selected vertices as loose";
1584         ot->idname = "OBJECT_OT_skin_loose_mark_clear";
1585
1586         ot->poll = skin_edit_poll;
1587         ot->exec = skin_loose_mark_clear_exec;
1588         
1589         /* flags */
1590         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1591
1592         RNA_def_enum(ot->srna, "action", action_items, SKIN_LOOSE_MARK, "Action", NULL);
1593 }
1594
1595 static int skin_radii_equalize_exec(bContext *C, wmOperator *UNUSED(op))
1596 {
1597         Object *ob = CTX_data_edit_object(C);
1598         BMEditMesh *em = BKE_editmesh_from_object(ob);
1599         BMesh *bm = em->bm;
1600         BMVert *bm_vert;
1601         BMIter bm_iter;
1602
1603         if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
1604                 return OPERATOR_CANCELLED;
1605         }
1606
1607         BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
1608                 if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
1609                         MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
1610                                                              bm_vert->head.data,
1611                                                              CD_MVERT_SKIN);
1612                         float avg = (vs->radius[0] + vs->radius[1]) * 0.5f;
1613
1614                         vs->radius[0] = vs->radius[1] = avg;
1615                 }
1616         }
1617
1618         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1619         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1620         
1621         return OPERATOR_FINISHED;
1622 }
1623
1624 void OBJECT_OT_skin_radii_equalize(wmOperatorType *ot)
1625 {
1626         ot->name = "Skin Radii Equalize";
1627         ot->description = "Make skin radii of selected vertices equal on each axis";
1628         ot->idname = "OBJECT_OT_skin_radii_equalize";
1629
1630         ot->poll = skin_edit_poll;
1631         ot->exec = skin_radii_equalize_exec;
1632         
1633         /* flags */
1634         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1635 }
1636
1637 static void skin_armature_bone_create(Object *skin_ob,
1638                                       MVert *mvert, MEdge *medge,
1639                                       bArmature *arm,
1640                                       BLI_bitmap *edges_visited,
1641                                       const MeshElemMap *emap,
1642                                       EditBone *parent_bone,
1643                                       int parent_v)
1644 {
1645         int i;
1646
1647         for (i = 0; i < emap[parent_v].count; i++) {
1648                 int endx = emap[parent_v].indices[i];
1649                 const MEdge *e = &medge[endx];
1650                 EditBone *bone;
1651                 bDeformGroup *dg;
1652                 int v;
1653
1654                 /* ignore edge if already visited */
1655                 if (BLI_BITMAP_TEST(edges_visited, endx))
1656                         continue;
1657                 BLI_BITMAP_ENABLE(edges_visited, endx);
1658
1659                 v = (e->v1 == parent_v ? e->v2 : e->v1);
1660
1661                 bone = ED_armature_edit_bone_add(arm, "Bone");
1662
1663                 bone->parent = parent_bone;
1664                 bone->flag |= BONE_CONNECTED;
1665
1666                 copy_v3_v3(bone->head, mvert[parent_v].co);
1667                 copy_v3_v3(bone->tail, mvert[v].co);
1668                 bone->rad_head = bone->rad_tail = 0.25;
1669                 BLI_snprintf(bone->name, sizeof(bone->name), "Bone.%.2d", endx);
1670
1671                 /* add bDeformGroup */
1672                 if ((dg = BKE_object_defgroup_add_name(skin_ob, bone->name))) {
1673                         ED_vgroup_vert_add(skin_ob, dg, parent_v, 1, WEIGHT_REPLACE);
1674                         ED_vgroup_vert_add(skin_ob, dg, v, 1, WEIGHT_REPLACE);
1675                 }
1676                 
1677                 skin_armature_bone_create(skin_ob,
1678                                           mvert, medge,
1679                                           arm,
1680                                           edges_visited,
1681                                           emap,
1682                                           bone,
1683                                           v);
1684         }
1685 }
1686
1687 static Object *modifier_skin_armature_create(Main *bmain, Scene *scene, Object *skin_ob)
1688 {
1689         BLI_bitmap *edges_visited;
1690         DerivedMesh *deform_dm;
1691         MVert *mvert;
1692         Mesh *me = skin_ob->data;
1693         Object *arm_ob;
1694         bArmature *arm;
1695         MVertSkin *mvert_skin;
1696         MeshElemMap *emap;
1697         int *emap_mem;
1698         int v;
1699
1700         deform_dm = mesh_get_derived_deform(scene, skin_ob, CD_MASK_BAREMESH);
1701         mvert = deform_dm->getVertArray(deform_dm);
1702
1703         /* add vertex weights to original mesh */
1704         CustomData_add_layer(&me->vdata,
1705                              CD_MDEFORMVERT,
1706                              CD_CALLOC,
1707                              NULL,
1708                              me->totvert);
1709         
1710         arm_ob = BKE_object_add(bmain, scene, OB_ARMATURE, NULL);
1711         BKE_object_transform_copy(arm_ob, skin_ob);
1712         arm = arm_ob->data;
1713         arm->layer = 1;
1714         arm_ob->dtx |= OB_DRAWXRAY;
1715         arm->drawtype = ARM_LINE;
1716         arm->edbo = MEM_callocN(sizeof(ListBase), "edbo armature");
1717
1718         mvert_skin = CustomData_get_layer(&me->vdata, CD_MVERT_SKIN);
1719         BKE_mesh_vert_edge_map_create(&emap, &emap_mem,
1720                              me->medge, me->totvert, me->totedge);
1721
1722         edges_visited = BLI_BITMAP_NEW(me->totedge, "edge_visited");
1723
1724         /* note: we use EditBones here, easier to set them up and use
1725          * edit-armature functions to convert back to regular bones */
1726         for (v = 0; v < me->totvert; v++) {
1727                 if (mvert_skin[v].flag & MVERT_SKIN_ROOT) {
1728                         EditBone *bone = NULL;
1729
1730                         /* Unless the skin root has just one adjacent edge, create
1731                          * a fake root bone (have it going off in the Y direction
1732                          * (arbitrary) */
1733                         if (emap[v].count > 1) {
1734                                 bone = ED_armature_edit_bone_add(arm, "Bone");
1735
1736                                 copy_v3_v3(bone->head, me->mvert[v].co);
1737                                 copy_v3_v3(bone->tail, me->mvert[v].co);
1738
1739                                 bone->head[1] = 1.0f;
1740                                 bone->rad_head = bone->rad_tail = 0.25;
1741                         }
1742                         
1743                         if (emap[v].count >= 1) {
1744                                 skin_armature_bone_create(skin_ob,
1745                                                           mvert, me->medge,
1746                                                           arm,
1747                                                           edges_visited,
1748                                                           emap,
1749                                                           bone,
1750                                                           v);
1751                         }
1752                 }
1753         }
1754
1755         MEM_freeN(edges_visited);
1756         MEM_freeN(emap);
1757         MEM_freeN(emap_mem);
1758
1759         ED_armature_from_edit(arm);
1760         ED_armature_edit_free(arm);
1761
1762         return arm_ob;
1763 }
1764
1765 static int skin_armature_create_exec(bContext *C, wmOperator *op)
1766 {
1767         Main *bmain = CTX_data_main(C);
1768         Scene *scene = CTX_data_scene(C);
1769         Object *ob = CTX_data_active_object(C), *arm_ob;
1770         Mesh *me = ob->data;
1771         ModifierData *skin_md;
1772         ArmatureModifierData *arm_md;
1773
1774         if (!CustomData_has_layer(&me->vdata, CD_MVERT_SKIN)) {
1775                 BKE_reportf(op->reports, RPT_WARNING, "Mesh '%s' has no skin vertex data", me->id.name + 2);
1776                 return OPERATOR_CANCELLED;
1777         }
1778
1779         /* create new armature */
1780         arm_ob = modifier_skin_armature_create(bmain, scene, ob);
1781
1782         /* add a modifier to connect the new armature to the mesh */
1783         arm_md = (ArmatureModifierData *)modifier_new(eModifierType_Armature);
1784         if (arm_md) {
1785                 skin_md = edit_modifier_property_get(op, ob, eModifierType_Skin);
1786                 BLI_insertlinkafter(&ob->modifiers, skin_md, arm_md);
1787
1788                 arm_md->object = arm_ob;
1789                 arm_md->deformflag = ARM_DEF_VGROUP | ARM_DEF_QUATERNION;
1790                 DAG_relations_tag_update(bmain);
1791                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1792         }
1793
1794         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1795
1796         return OPERATOR_FINISHED;
1797 }
1798
1799 static int skin_armature_create_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1800 {
1801         if (edit_modifier_invoke_properties(C, op))
1802                 return skin_armature_create_exec(C, op);
1803         else
1804                 return OPERATOR_CANCELLED;
1805 }
1806
1807 void OBJECT_OT_skin_armature_create(wmOperatorType *ot)
1808 {
1809         ot->name = "Skin Armature Create";
1810         ot->description = "Create an armature that parallels the skin layout";
1811         ot->idname = "OBJECT_OT_skin_armature_create";
1812
1813         ot->poll = skin_poll;
1814         ot->invoke = skin_armature_create_invoke;
1815         ot->exec = skin_armature_create_exec;
1816         
1817         /* flags */
1818         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1819         edit_modifier_properties(ot);
1820 }
1821 /************************ delta mush bind operator *********************/
1822
1823 static int correctivesmooth_poll(bContext *C)
1824 {
1825         return edit_modifier_poll_generic(C, &RNA_CorrectiveSmoothModifier, 0);
1826 }
1827
1828 static int correctivesmooth_bind_exec(bContext *C, wmOperator *op)
1829 {
1830         Scene *scene = CTX_data_scene(C);
1831         Object *ob = ED_object_active_context(C);
1832         CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)edit_modifier_property_get(op, ob, eModifierType_CorrectiveSmooth);
1833         bool is_bind;
1834
1835         if (!csmd) {
1836                 return OPERATOR_CANCELLED;
1837         }
1838
1839         if (!modifier_isEnabled(scene, &csmd->modifier, eModifierMode_Realtime)) {
1840                 BKE_report(op->reports, RPT_ERROR, "Modifier is disabled");
1841                 return OPERATOR_CANCELLED;
1842         }
1843
1844         is_bind = (csmd->bind_coords != NULL);
1845
1846         MEM_SAFE_FREE(csmd->bind_coords);
1847         MEM_SAFE_FREE(csmd->delta_cache);
1848
1849         if (is_bind) {
1850                 /* toggle off */
1851                 csmd->bind_coords_num = 0;
1852         }
1853         else {
1854                 /* signal to modifier to recalculate */
1855                 csmd->bind_coords_num = (unsigned int)-1;
1856         }
1857
1858         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1859         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1860
1861         return OPERATOR_FINISHED;
1862 }
1863
1864 static int correctivesmooth_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1865 {
1866         if (edit_modifier_invoke_properties(C, op))
1867                 return correctivesmooth_bind_exec(C, op);
1868         else
1869                 return OPERATOR_CANCELLED;
1870 }
1871
1872 void OBJECT_OT_correctivesmooth_bind(wmOperatorType *ot)
1873 {
1874         /* identifiers */
1875         ot->name = "Corrective Smooth Bind";
1876         ot->description = "Bind base pose in Corrective Smooth modifier";
1877         ot->idname = "OBJECT_OT_correctivesmooth_bind";
1878
1879         /* api callbacks */
1880         ot->poll = correctivesmooth_poll;
1881         ot->invoke = correctivesmooth_bind_invoke;
1882         ot->exec = correctivesmooth_bind_exec;
1883
1884         /* flags */
1885         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1886         edit_modifier_properties(ot);
1887 }
1888
1889 /************************ mdef bind operator *********************/
1890
1891 static int meshdeform_poll(bContext *C)
1892 {
1893         return edit_modifier_poll_generic(C, &RNA_MeshDeformModifier, 0);
1894 }
1895
1896 static int meshdeform_bind_exec(bContext *C, wmOperator *op)
1897 {
1898         Scene *scene = CTX_data_scene(C);
1899         Object *ob = ED_object_active_context(C);
1900         MeshDeformModifierData *mmd = (MeshDeformModifierData *)edit_modifier_property_get(op, ob, eModifierType_MeshDeform);
1901         
1902         if (!mmd)
1903                 return OPERATOR_CANCELLED;
1904
1905         if (mmd->bindcagecos) {
1906                 MEM_freeN(mmd->bindcagecos);
1907                 if (mmd->dyngrid) MEM_freeN(mmd->dyngrid);
1908                 if (mmd->dyninfluences) MEM_freeN(mmd->dyninfluences);
1909                 if (mmd->bindinfluences) MEM_freeN(mmd->bindinfluences);
1910                 if (mmd->bindoffsets) MEM_freeN(mmd->bindoffsets);
1911                 if (mmd->dynverts) MEM_freeN(mmd->dynverts);
1912                 if (mmd->bindweights) MEM_freeN(mmd->bindweights);  /* deprecated */
1913                 if (mmd->bindcos) MEM_freeN(mmd->bindcos);  /* deprecated */
1914
1915                 mmd->bindcagecos = NULL;
1916                 mmd->dyngrid = NULL;
1917                 mmd->dyninfluences = NULL;
1918                 mmd->bindinfluences = NULL;
1919                 mmd->bindoffsets = NULL;
1920                 mmd->dynverts = NULL;
1921                 mmd->bindweights = NULL; /* deprecated */
1922                 mmd->bindcos = NULL; /* deprecated */
1923                 mmd->totvert = 0;
1924                 mmd->totcagevert = 0;
1925                 mmd->totinfluence = 0;
1926                 
1927                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
1928                 WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
1929         }
1930         else {
1931                 DerivedMesh *dm;
1932                 int mode = mmd->modifier.mode;
1933
1934                 /* force modifier to run, it will call binding routine */
1935                 mmd->bindfunc = mesh_deform_bind;
1936                 mmd->modifier.mode |= eModifierMode_Realtime;
1937
1938                 if (ob->type == OB_MESH) {
1939                         dm = mesh_create_derived_view(scene, ob, 0);
1940                         dm->release(dm);
1941                 }
1942                 else if (ob->type == OB_LATTICE) {
1943                         BKE_lattice_modifiers_calc(scene, ob);
1944                 }
1945                 else if (ob->type == OB_MBALL) {
1946                         BKE_displist_make_mball(CTX_data_main(C)->eval_ctx, scene, ob);
1947                 }
1948                 else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
1949                         BKE_displist_make_curveTypes(scene, ob, 0);
1950                 }
1951
1952                 mmd->bindfunc = NULL;
1953                 mmd->modifier.mode = mode;
1954         }
1955         
1956         return OPERATOR_FINISHED;
1957 }
1958
1959 static int meshdeform_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1960 {
1961         if (edit_modifier_invoke_properties(C, op))
1962                 return meshdeform_bind_exec(C, op);
1963         else 
1964                 return OPERATOR_CANCELLED;
1965 }
1966
1967 void OBJECT_OT_meshdeform_bind(wmOperatorType *ot)
1968 {
1969         /* identifiers */
1970         ot->name = "Mesh Deform Bind";
1971         ot->description = "Bind mesh to cage in mesh deform modifier";
1972         ot->idname = "OBJECT_OT_meshdeform_bind";
1973         
1974         /* api callbacks */
1975         ot->poll = meshdeform_poll;
1976         ot->invoke = meshdeform_bind_invoke;
1977         ot->exec = meshdeform_bind_exec;
1978         
1979         /* flags */
1980         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1981         edit_modifier_properties(ot);
1982 }
1983
1984 /****************** explode refresh operator *********************/
1985
1986 static int explode_poll(bContext *C)
1987 {
1988         return edit_modifier_poll_generic(C, &RNA_ExplodeModifier, 0);
1989 }
1990
1991 static int explode_refresh_exec(bContext *C, wmOperator *op)
1992 {
1993         Object *ob = ED_object_active_context(C);
1994         ExplodeModifierData *emd = (ExplodeModifierData *)edit_modifier_property_get(op, ob, eModifierType_Explode);
1995         
1996         if (!emd)
1997                 return OPERATOR_CANCELLED;
1998
1999         emd->flag |= eExplodeFlag_CalcFaces;
2000
2001         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
2002         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
2003         
2004         return OPERATOR_FINISHED;
2005 }
2006
2007 static int explode_refresh_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2008 {
2009         if (edit_modifier_invoke_properties(C, op))
2010                 return explode_refresh_exec(C, op);
2011         else
2012                 return OPERATOR_CANCELLED;
2013 }
2014
2015
2016 void OBJECT_OT_explode_refresh(wmOperatorType *ot)
2017 {
2018         ot->name = "Explode Refresh";
2019         ot->description = "Refresh data in the Explode modifier";
2020         ot->idname = "OBJECT_OT_explode_refresh";
2021
2022         ot->poll = explode_poll;
2023         ot->invoke = explode_refresh_invoke;
2024         ot->exec = explode_refresh_exec;
2025         
2026         /* flags */
2027         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
2028         edit_modifier_properties(ot);
2029 }
2030
2031
2032 /****************** ocean bake operator *********************/
2033
2034 static int ocean_bake_poll(bContext *C)
2035 {
2036         return edit_modifier_poll_generic(C, &RNA_OceanModifier, 0);
2037 }
2038
2039 /* copied from init_ocean_modifier, MOD_ocean.c */
2040 static void init_ocean_modifier_bake(struct Ocean *oc, struct OceanModifierData *omd)
2041 {
2042         int do_heightfield, do_chop, do_normals, do_jacobian;
2043         
2044         if (!omd || !oc) return; 
2045         
2046         do_heightfield = true;
2047         do_chop = (omd->chop_amount > 0);
2048         do_normals = (omd->flag & MOD_OCEAN_GENERATE_NORMALS);
2049         do_jacobian = (omd->flag & MOD_OCEAN_GENERATE_FOAM);
2050         
2051         BKE_ocean_init(oc, omd->resolution * omd->resolution, omd->resolution * omd->resolution, omd->spatial_size, omd->spatial_size,
2052                        omd->wind_velocity, omd->smallest_wave, 1.0, omd->wave_direction, omd->damp, omd->wave_alignment,
2053                        omd->depth, omd->time,
2054                        do_heightfield, do_chop, do_normals, do_jacobian,
2055                        omd->seed);
2056 }
2057
2058 typedef struct OceanBakeJob {
2059         /* from wmJob */
2060         void *owner;
2061         short *stop, *do_update;
2062         float *progress;
2063         int current_frame;
2064         struct OceanCache *och;
2065         struct Ocean *ocean;
2066         struct OceanModifierData *omd;
2067 } OceanBakeJob;
2068
2069 static void oceanbake_free(void *customdata)
2070 {
2071         OceanBakeJob *oj = customdata;
2072         MEM_freeN(oj);
2073 }
2074
2075 /* called by oceanbake, only to check job 'stop' value */
2076 static int oceanbake_breakjob(void *UNUSED(customdata))
2077 {
2078         //OceanBakeJob *ob = (OceanBakeJob *)customdata;
2079         //return *(ob->stop);
2080         
2081         /* this is not nice yet, need to make the jobs list template better 
2082          * for identifying/acting upon various different jobs */
2083         /* but for now we'll reuse the render break... */
2084         return (G.is_break);
2085 }
2086
2087 /* called by oceanbake, wmJob sends notifier */
2088 static void oceanbake_update(void *customdata, float progress, int *cancel)
2089 {
2090         OceanBakeJob *oj = customdata;
2091         
2092         if (oceanbake_breakjob(oj))
2093                 *cancel = 1;
2094         
2095         *(oj->do_update) = true;
2096         *(oj->progress) = progress;
2097 }
2098
2099 static void oceanbake_startjob(void *customdata, short *stop, short *do_update, float *progress)
2100 {
2101         OceanBakeJob *oj = customdata;
2102         
2103         oj->stop = stop;
2104         oj->do_update = do_update;
2105         oj->progress = progress;
2106         
2107         G.is_break = false;   /* XXX shared with render - replace with job 'stop' switch */
2108         
2109         BKE_ocean_bake(oj->ocean, oj->och, oceanbake_update, (void *)oj);
2110         
2111         *do_update = true;
2112         *stop = 0;
2113 }
2114
2115 static void oceanbake_endjob(void *customdata)
2116 {
2117         OceanBakeJob *oj = customdata;
2118         
2119         if (oj->ocean) {
2120                 BKE_ocean_free(oj->ocean);
2121                 oj->ocean = NULL;
2122         }
2123         
2124         oj->omd->oceancache = oj->och;
2125         oj->omd->cached = true;
2126 }
2127
2128 static int ocean_bake_exec(bContext *C, wmOperator *op)
2129 {
2130         Object *ob = ED_object_active_context(C);
2131         OceanModifierData *omd = (OceanModifierData *)edit_modifier_property_get(op, ob, eModifierType_Ocean);
2132         Scene *scene = CTX_data_scene(C);
2133         OceanCache *och;
2134         struct Ocean *ocean;
2135         int f, cfra, i = 0;
2136         const bool free = RNA_boolean_get(op->ptr, "free");
2137         
2138         wmJob *wm_job;
2139         OceanBakeJob *oj;
2140         
2141         if (!omd)
2142                 return OPERATOR_CANCELLED;
2143         
2144         if (free) {
2145                 omd->refresh |= MOD_OCEAN_REFRESH_CLEAR_CACHE;
2146                 DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
2147                 WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
2148                 return OPERATOR_FINISHED;
2149         }
2150
2151         och = BKE_ocean_init_cache(omd->cachepath, modifier_path_relbase(ob),
2152                                    omd->bakestart, omd->bakeend, omd->wave_scale,
2153                                    omd->chop_amount, omd->foam_coverage, omd->foam_fade, omd->resolution);
2154         
2155         och->time = MEM_mallocN(och->duration * sizeof(float), "foam bake time");
2156         
2157         cfra = scene->r.cfra;
2158         
2159         /* precalculate time variable before baking */
2160         for (f = omd->bakestart; f <= omd->bakeend; f++) {
2161                 /* from physics_fluid.c:
2162                  *
2163                  * XXX: This can't be used due to an anim sys optimization that ignores recalc object animation,
2164                  * leaving it for the depgraph (this ignores object animation such as modifier properties though... :/ )
2165                  * --> BKE_animsys_evaluate_all_animation(G.main, eval_time);
2166                  * This doesn't work with drivers:
2167                  * --> BKE_animsys_evaluate_animdata(&fsDomain->id, fsDomain->adt, eval_time, ADT_RECALC_ALL);
2168                  */
2169                 
2170                 /* Modifying the global scene isn't nice, but we can do it in 
2171                  * this part of the process before a threaded job is created */
2172                 
2173                 //scene->r.cfra = f;
2174                 //ED_update_for_newframe(CTX_data_main(C), scene, 1);
2175                 
2176                 /* ok, this doesn't work with drivers, but is way faster. 
2177                  * let's use this for now and hope nobody wants to drive the time value... */
2178                 BKE_animsys_evaluate_animdata(scene, (ID *)ob, ob->adt, f, ADT_RECALC_ANIM);
2179                 
2180                 och->time[i] = omd->time;
2181                 i++;
2182         }
2183         
2184         /* make a copy of ocean to use for baking - threadsafety */
2185         ocean = BKE_ocean_add();
2186         init_ocean_modifier_bake(ocean, omd);
2187         
2188 #if 0
2189         BKE_ocean_bake(ocean, och);
2190         
2191         omd->oceancache = och;
2192         omd->cached = true;
2193         
2194         scene->r.cfra = cfra;
2195         
2196         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
2197         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
2198 #endif
2199         
2200         /* job stuff */
2201         
2202         scene->r.cfra = cfra;
2203         
2204         /* setup job */
2205         wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Ocean Simulation",
2206                              WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_SIM_OCEAN);
2207         oj = MEM_callocN(sizeof(OceanBakeJob), "ocean bake job");
2208         oj->ocean = ocean;
2209         oj->och = och;
2210         oj->omd = omd;
2211         
2212         WM_jobs_customdata_set(wm_job, oj, oceanbake_free);
2213         WM_jobs_timer(wm_job, 0.1, NC_OBJECT | ND_MODIFIER, NC_OBJECT | ND_MODIFIER);
2214         WM_jobs_callbacks(wm_job, oceanbake_startjob, NULL, NULL, oceanbake_endjob);
2215         
2216         WM_jobs_start(CTX_wm_manager(C), wm_job);
2217         
2218         
2219         
2220         return OPERATOR_FINISHED;
2221 }
2222
2223 static int ocean_bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2224 {
2225         if (edit_modifier_invoke_properties(C, op))
2226                 return ocean_bake_exec(C, op);
2227         else
2228                 return OPERATOR_CANCELLED;
2229 }
2230
2231
2232 void OBJECT_OT_ocean_bake(wmOperatorType *ot)
2233 {
2234         ot->name = "Bake Ocean";
2235         ot->description = "Bake an image sequence of ocean data";
2236         ot->idname = "OBJECT_OT_ocean_bake";
2237         
2238         ot->poll = ocean_bake_poll;
2239         ot->invoke = ocean_bake_invoke;
2240         ot->exec = ocean_bake_exec;
2241         
2242         /* flags */
2243         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
2244         edit_modifier_properties(ot);
2245         
2246         RNA_def_boolean(ot->srna, "free", false, "Free", "Free the bake, rather than generating it");
2247 }
2248
2249 /************************ LaplacianDeform bind operator *********************/
2250
2251 static int laplaciandeform_poll(bContext *C)
2252 {
2253         return edit_modifier_poll_generic(C, &RNA_LaplacianDeformModifier, 0);
2254 }
2255
2256 static int laplaciandeform_bind_exec(bContext *C, wmOperator *op)
2257 {
2258         Object *ob = ED_object_active_context(C);
2259         LaplacianDeformModifierData *lmd = (LaplacianDeformModifierData *)edit_modifier_property_get(op, ob, eModifierType_LaplacianDeform);
2260
2261         if (!lmd)
2262                 return OPERATOR_CANCELLED;
2263         if (lmd->flag & MOD_LAPLACIANDEFORM_BIND) {
2264                 lmd->flag &= ~MOD_LAPLACIANDEFORM_BIND;
2265         }
2266         else {
2267                 lmd->flag |= MOD_LAPLACIANDEFORM_BIND;
2268         }
2269         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
2270         WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
2271         return OPERATOR_FINISHED;
2272 }
2273
2274 static int laplaciandeform_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2275 {
2276         if (edit_modifier_invoke_properties(C, op))
2277                 return laplaciandeform_bind_exec(C, op);
2278         else 
2279                 return OPERATOR_CANCELLED;
2280 }
2281
2282 void OBJECT_OT_laplaciandeform_bind(wmOperatorType *ot)
2283 {
2284         /* identifiers */
2285         ot->name = "Laplacian Deform Bind";
2286         ot->description = "Bind mesh to system in laplacian deform modifier";
2287         ot->idname = "OBJECT_OT_laplaciandeform_bind";
2288         
2289         /* api callbacks */
2290         ot->poll = laplaciandeform_poll;
2291         ot->invoke = laplaciandeform_bind_invoke;
2292         ot->exec = laplaciandeform_bind_exec;
2293         
2294         /* flags */
2295         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
2296         edit_modifier_properties(ot);
2297 }