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