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