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