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