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