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