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