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