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