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