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