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