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