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