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