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