Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / 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) 2005 by the Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Daniel Dunbar
22  *                 Ton Roosendaal,
23  *                 Ben Batt,
24  *                 Brecht Van Lommel,
25  *                 Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  *
29  * Modifier stack implementation.
30  *
31  * BKE_modifier.h contains the function prototypes for this file.
32  *
33  */
34
35 /** \file blender/blenkernel/intern/modifier.c
36  *  \ingroup bke
37  */
38
39 #include <stdlib.h>
40 #include <stddef.h>
41 #include <string.h>
42 #include <stdarg.h>
43 #include <math.h>
44 #include <float.h>
45
46 #include "MEM_guardedalloc.h"
47
48 #include "DNA_armature_types.h"
49 #include "DNA_mesh_types.h"
50 #include "DNA_object_types.h"
51
52 #include "BLI_utildefines.h"
53 #include "BLI_listbase.h"
54 #include "BLI_linklist.h"
55 #include "BLI_path_util.h"
56 #include "BLI_string.h"
57 #include "BLI_string_utils.h"
58
59 #include "BLT_translation.h"
60
61 #include "BKE_appdir.h"
62 #include "BKE_cdderivedmesh.h"
63 #include "BKE_idcode.h"
64 #include "BKE_key.h"
65 #include "BKE_library.h"
66 #include "BKE_library_query.h"
67 #include "BKE_mesh.h"
68 #include "BKE_multires.h"
69 #include "BKE_DerivedMesh.h"
70
71 /* may move these, only for modifier_path_relbase */
72 #include "BKE_global.h" /* ugh, G.main->name only */
73 #include "BKE_main.h"
74 /* end */
75
76 #include "DEG_depsgraph.h"
77
78 #include "MOD_modifiertypes.h"
79
80 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
81 static VirtualModifierData virtualModifierCommonData;
82
83 void BKE_modifier_init(void)
84 {
85         ModifierData *md;
86
87         /* Initialize modifier types */
88         modifier_type_init(modifier_types); /* MOD_utils.c */
89
90         /* Initialize global cmmon storage used for virtual modifier list */
91         md = modifier_new(eModifierType_Armature);
92         virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
93         modifier_free(md);
94
95         md = modifier_new(eModifierType_Curve);
96         virtualModifierCommonData.cmd = *((CurveModifierData *) md);
97         modifier_free(md);
98
99         md = modifier_new(eModifierType_Lattice);
100         virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
101         modifier_free(md);
102
103         md = modifier_new(eModifierType_ShapeKey);
104         virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
105         modifier_free(md);
106
107         virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
108         virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
109         virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
110         virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
111 }
112
113 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
114 {
115         /* type unsigned, no need to check < 0 */
116         if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
117                 return modifier_types[type];
118         }
119         else {
120                 return NULL;
121         }
122 }
123
124 /***/
125
126 ModifierData *modifier_new(int type)
127 {
128         const ModifierTypeInfo *mti = modifierType_getInfo(type);
129         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
130         
131         /* note, this name must be made unique later */
132         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
133
134         md->type = type;
135         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
136         md->flag = eModifierFlag_StaticOverride_Local;
137
138         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
139                 md->mode |= eModifierMode_Editmode;
140
141         if (mti->initData) mti->initData(md);
142
143         return md;
144 }
145
146 static void modifier_free_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
147 {
148         ID *id = *idpoin;
149         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
150                 id_us_min(id);
151         }
152 }
153
154 void modifier_free_ex(ModifierData *md, const int flag)
155 {
156         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
157
158         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
159                 if (mti->foreachIDLink) {
160                         mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
161                 }
162                 else if (mti->foreachObjectLink) {
163                         mti->foreachObjectLink(md, NULL, (ObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
164                 }
165         }
166
167         if (mti->freeData) mti->freeData(md);
168         if (md->error) MEM_freeN(md->error);
169
170         MEM_freeN(md);
171 }
172
173 void modifier_free(ModifierData *md)
174 {
175         modifier_free_ex(md, 0);
176 }
177
178 bool modifier_unique_name(ListBase *modifiers, ModifierData *md)
179 {
180         if (modifiers && md) {
181                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
182
183                 return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
184         }
185         return false;
186 }
187
188 bool modifier_dependsOnTime(ModifierData *md)
189 {
190         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
191
192         return mti->dependsOnTime && mti->dependsOnTime(md);
193 }
194
195 bool modifier_supportsMapping(ModifierData *md)
196 {
197         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
198
199         return (mti->type == eModifierTypeType_OnlyDeform ||
200                 (mti->flags & eModifierTypeFlag_SupportsMapping));
201 }
202
203 bool modifier_isPreview(ModifierData *md)
204 {
205         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
206
207         /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
208         if (!((mti->flags & eModifierTypeFlag_UsesPreview) || (mti->type == eModifierTypeType_Constructive))) {
209                 return false;
210         }
211
212         if (md->mode & eModifierMode_Realtime) {
213                 return true;
214         }
215
216         return false;
217 }
218
219 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
220 {
221         ModifierData *md = ob->modifiers.first;
222
223         for (; md; md = md->next)
224                 if (md->type == type)
225                         break;
226
227         return md;
228 }
229
230 ModifierData *modifiers_findByName(Object *ob, const char *name)
231 {
232         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
233 }
234
235 void modifiers_clearErrors(Object *ob)
236 {
237         ModifierData *md = ob->modifiers.first;
238         /* int qRedraw = 0; */
239
240         for (; md; md = md->next) {
241                 if (md->error) {
242                         MEM_freeN(md->error);
243                         md->error = NULL;
244
245                         /* qRedraw = 1; */
246                 }
247         }
248 }
249
250 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, void *userData)
251 {
252         ModifierData *md = ob->modifiers.first;
253
254         for (; md; md = md->next) {
255                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
256
257                 if (mti->foreachObjectLink)
258                         mti->foreachObjectLink(md, ob, walk, userData);
259         }
260 }
261
262 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
263 {
264         ModifierData *md = ob->modifiers.first;
265
266         for (; md; md = md->next) {
267                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
268
269                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
270                 else if (mti->foreachObjectLink) {
271                         /* each Object can masquerade as an ID, so this should be OK */
272                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
273                         mti->foreachObjectLink(md, ob, fp, userData);
274                 }
275         }
276 }
277
278 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
279 {
280         ModifierData *md = ob->modifiers.first;
281
282         for (; md; md = md->next) {
283                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
284
285                 if (mti->foreachTexLink)
286                         mti->foreachTexLink(md, ob, walk, userData);
287         }
288 }
289
290 /* callback's can use this
291  * to avoid copying every member.
292  */
293 void modifier_copyData_generic(const ModifierData *md_src, ModifierData *md_dst)
294 {
295         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
296
297         /* md_dst may have alredy be fully initialized with some extra allocated data,
298          * we need to free it now to avoid memleak. */
299         if (mti->freeData) {
300                 mti->freeData(md_dst);
301         }
302
303         const size_t data_size = sizeof(ModifierData);
304         const char *md_src_data = ((const char *)md_src) + data_size;
305         char       *md_dst_data =       ((char *)md_dst) + data_size;
306         BLI_assert(data_size <= (size_t)mti->structSize);
307         memcpy(md_dst_data, md_src_data, (size_t)mti->structSize - data_size);
308 }
309
310 static void modifier_copy_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
311 {
312         ID *id = *idpoin;
313         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
314                 id_us_plus(id);
315         }
316 }
317
318 void modifier_copyData_ex(ModifierData *md, ModifierData *target, const int flag)
319 {
320         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
321
322         target->mode = md->mode;
323         target->flag = md->flag;
324
325         if (mti->copyData) {
326                 mti->copyData(md, target);
327         }
328
329         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
330                 if (mti->foreachIDLink) {
331                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
332                 }
333                 else if (mti->foreachObjectLink) {
334                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
335                 }
336         }
337 }
338
339 void modifier_copyData(ModifierData *md, ModifierData *target)
340 {
341         modifier_copyData_ex(md, target, 0);
342 }
343
344
345 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
346 {
347         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
348
349         md->scene = scene;
350
351         return ((!mti->isDisabled || !mti->isDisabled(md, 0)) &&
352                 (mti->flags & eModifierTypeFlag_SupportsEditmode) &&
353                 modifier_supportsMapping(md));
354 }
355
356 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
357 {
358         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
359
360         md->scene = scene;
361
362         return ((md->mode & eModifierMode_Realtime) &&
363                 (md->mode & eModifierMode_Editmode) &&
364                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
365                 modifier_supportsMapping(md));
366 }
367
368 bool modifier_isSameTopology(ModifierData *md)
369 {
370         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
371         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
372 }
373
374 bool modifier_isNonGeometrical(ModifierData *md)
375 {
376         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
377         return (mti->type == eModifierTypeType_NonGeometrical);
378 }
379
380 void modifier_setError(ModifierData *md, const char *_format, ...)
381 {
382         char buffer[512];
383         va_list ap;
384         const char *format = TIP_(_format);
385
386         va_start(ap, _format);
387         vsnprintf(buffer, sizeof(buffer), format, ap);
388         va_end(ap);
389         buffer[sizeof(buffer) - 1] = '\0';
390
391         if (md->error)
392                 MEM_freeN(md->error);
393
394         md->error = BLI_strdup(buffer);
395
396 }
397
398 /* used for buttons, to find out if the 'draw deformed in editmode' option is
399  * there
400  * 
401  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
402  * then is NULL) 
403  * also used for some mesh tools to give warnings
404  */
405 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
406 {
407         VirtualModifierData virtualModifierData;
408         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
409         int i, cageIndex = -1;
410
411         if (r_lastPossibleCageIndex) {
412                 /* ensure the value is initialized */
413                 *r_lastPossibleCageIndex = -1;
414         }
415
416         /* Find the last modifier acting on the cage. */
417         for (i = 0; md; i++, md = md->next) {
418                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
419                 bool supports_mapping;
420
421                 md->scene = scene;
422
423                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
424                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
425                 if (md->mode & eModifierMode_DisableTemporary) continue;
426
427                 supports_mapping = modifier_supportsMapping(md);
428                 if (r_lastPossibleCageIndex && supports_mapping) {
429                         *r_lastPossibleCageIndex = i;
430                 }
431
432                 if (!(md->mode & eModifierMode_Realtime)) continue;
433                 if (!(md->mode & eModifierMode_Editmode)) continue;
434
435                 if (!supports_mapping)
436                         break;
437
438                 if (md->mode & eModifierMode_OnCage)
439                         cageIndex = i;
440         }
441
442         return cageIndex;
443 }
444
445
446 bool modifiers_isSoftbodyEnabled(Object *ob)
447 {
448         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
449
450         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
451 }
452
453 bool modifiers_isClothEnabled(Object *ob)
454 {
455         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
456
457         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
458 }
459
460 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
461 {
462         ModifierData *md = modifiers_findByType(ob, modifierType);
463
464         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
465 }
466
467 bool modifiers_isParticleEnabled(Object *ob)
468 {
469         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
470
471         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
472 }
473
474 /**
475  * Check whether is enabled.
476  *
477  * \param scene Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
478  */
479 bool modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
480 {
481         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
482
483         md->scene = scene;
484
485         if ((md->mode & required_mode) != required_mode) return false;
486         if (scene != NULL && mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return false;
487         if (md->mode & eModifierMode_DisableTemporary) return false;
488         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
489         
490         return true;
491 }
492
493 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
494                                     CustomDataMask dataMask, int required_mode,
495                                     ModifierData *previewmd, CustomDataMask previewmask)
496 {
497         CDMaskLink *dataMasks = NULL;
498         CDMaskLink *curr, *prev;
499
500         /* build a list of modifier data requirements in reverse order */
501         for (; md; md = md->next) {
502                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
503
504                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
505                 
506                 if (modifier_isEnabled(scene, md, required_mode)) {
507                         if (mti->requiredDataMask)
508                                 curr->mask = mti->requiredDataMask(ob, md);
509
510                         if (previewmd == md) {
511                                 curr->mask |= previewmask;
512                         }
513                 }
514
515                 /* prepend new datamask */
516                 curr->next = dataMasks;
517                 dataMasks = curr;
518         }
519
520         /* build the list of required data masks - each mask in the list must
521          * include all elements of the masks that follow it
522          *
523          * note the list is currently in reverse order, so "masks that follow it"
524          * actually means "masks that precede it" at the moment
525          */
526         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
527                 if (prev) {
528                         CustomDataMask prev_mask = prev->mask;
529                         CustomDataMask curr_mask = curr->mask;
530
531                         curr->mask = curr_mask | prev_mask;
532                 }
533                 else {
534                         CustomDataMask curr_mask = curr->mask;
535
536                         curr->mask = curr_mask | dataMask;
537                 }
538         }
539
540         /* reverse the list so it's in the correct order */
541         BLI_linklist_reverse((LinkNode **)&dataMasks);
542
543         return dataMasks;
544 }
545
546 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
547 {
548         ModifierData *tmp_md = NULL;
549
550         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
551                 return tmp_md;
552
553         /* Find the latest modifier in stack generating preview. */
554         for (; md; md = md->next) {
555                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
556                         tmp_md = md;
557         }
558         return tmp_md;
559 }
560
561 /* NOTE: This is to support old files from before Blender supported modifiers,
562  * in some cases versioning code updates these so for new files this will
563  * return an empty list. */
564 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
565 {
566         ModifierData *md;
567
568         md = ob->modifiers.first;
569
570         *virtualModifierData = virtualModifierCommonData;
571
572         if (ob->parent) {
573                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
574                         virtualModifierData->amd.object = ob->parent;
575                         virtualModifierData->amd.modifier.next = md;
576                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
577                         md = &virtualModifierData->amd.modifier;
578                 }
579                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
580                         virtualModifierData->cmd.object = ob->parent;
581                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
582                         virtualModifierData->cmd.modifier.next = md;
583                         md = &virtualModifierData->cmd.modifier;
584                 }
585                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
586                         virtualModifierData->lmd.object = ob->parent;
587                         virtualModifierData->lmd.modifier.next = md;
588                         md = &virtualModifierData->lmd.modifier;
589                 }
590         }
591
592         /* shape key modifier, not yet for curves */
593         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
594                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
595                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
596                 else
597                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
598
599                 virtualModifierData->smd.modifier.next = md;
600                 md = &virtualModifierData->smd.modifier;
601         }
602
603         return md;
604 }
605
606 /* Takes an object and returns its first selected armature, else just its armature
607  * This should work for multiple armatures per object
608  */
609 Object *modifiers_isDeformedByArmature(Object *ob)
610 {
611         VirtualModifierData virtualModifierData;
612         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
613         ArmatureModifierData *amd = NULL;
614         
615         /* return the first selected armature, this lets us use multiple armatures */
616         for (; md; md = md->next) {
617                 if (md->type == eModifierType_Armature) {
618                         amd = (ArmatureModifierData *) md;
619                         if (amd->object && (amd->object->flag & SELECT))
620                                 return amd->object;
621                 }
622         }
623         
624         if (amd) /* if were still here then return the last armature */
625                 return amd->object;
626         
627         return NULL;
628 }
629
630 /* Takes an object and returns its first selected lattice, else just its lattice
631  * This should work for multiple lattices per object
632  */
633 Object *modifiers_isDeformedByLattice(Object *ob)
634 {
635         VirtualModifierData virtualModifierData;
636         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
637         LatticeModifierData *lmd = NULL;
638         
639         /* return the first selected lattice, this lets us use multiple lattices */
640         for (; md; md = md->next) {
641                 if (md->type == eModifierType_Lattice) {
642                         lmd = (LatticeModifierData *) md;
643                         if (lmd->object && (lmd->object->flag & SELECT))
644                                 return lmd->object;
645                 }
646         }
647         
648         if (lmd) /* if were still here then return the last lattice */
649                 return lmd->object;
650         
651         return NULL;
652 }
653
654 /* Takes an object and returns its first selected curve, else just its curve
655  * This should work for multiple curves per object
656  */
657 Object *modifiers_isDeformedByCurve(Object *ob)
658 {
659         VirtualModifierData virtualModifierData;
660         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
661         CurveModifierData *cmd = NULL;
662         
663         /* return the first selected curve, this lets us use multiple curves */
664         for (; md; md = md->next) {
665                 if (md->type == eModifierType_Curve) {
666                         cmd = (CurveModifierData *) md;
667                         if (cmd->object && (cmd->object->flag & SELECT))
668                                 return cmd->object;
669                 }
670         }
671         
672         if (cmd) /* if were still here then return the last curve */
673                 return cmd->object;
674         
675         return NULL;
676 }
677
678 bool modifiers_usesArmature(Object *ob, bArmature *arm)
679 {
680         VirtualModifierData virtualModifierData;
681         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
682
683         for (; md; md = md->next) {
684                 if (md->type == eModifierType_Armature) {
685                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
686                         if (amd->object && amd->object->data == arm)
687                                 return true;
688                 }
689         }
690
691         return false;
692 }
693
694 bool modifier_isCorrectableDeformed(ModifierData *md)
695 {
696         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
697         return (mti->deformMatricesEM != NULL) || (mti->deformMatricesEM_DM != NULL);
698 }
699
700 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
701 {
702         VirtualModifierData virtualModifierData;
703         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
704         int required_mode = eModifierMode_Realtime;
705
706         if (ob->mode == OB_MODE_EDIT) {
707                 required_mode |= eModifierMode_Editmode;
708         }
709         for (; md; md = md->next) {
710                 if (!modifier_isEnabled(scene, md, required_mode)) {
711                         /* pass */
712                 }
713                 else if (modifier_isCorrectableDeformed(md)) {
714                         return true;
715                 }
716         }
717         return false;
718 }
719
720 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
721  * to preview something... Used by DynamicPaint and WeightVG currently. */
722 bool modifiers_isPreview(Object *ob)
723 {
724         ModifierData *md = ob->modifiers.first;
725
726         for (; md; md = md->next) {
727                 if (modifier_isPreview(md))
728                         return true;
729         }
730
731         return false;
732 }
733
734 void modifier_freeTemporaryData(ModifierData *md)
735 {
736         if (md->type == eModifierType_Armature) {
737                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
738
739                 if (amd->prevCos) {
740                         MEM_freeN(amd->prevCos);
741                         amd->prevCos = NULL;
742                 }
743         }
744 }
745
746 /* ensure modifier correctness when changing ob->data */
747 void test_object_modifiers(Object *ob)
748 {
749         ModifierData *md;
750
751         /* just multires checked for now, since only multires
752          * modifies mesh data */
753
754         if (ob->type != OB_MESH) return;
755
756         for (md = ob->modifiers.first; md; md = md->next) {
757                 if (md->type == eModifierType_Multires) {
758                         MultiresModifierData *mmd = (MultiresModifierData *)md;
759
760                         multiresModifier_set_levels_from_disps(mmd, ob);
761                 }
762         }
763 }
764
765 /* where should this go?, it doesnt fit well anywhere :S - campbell */
766
767 /* elubie: changed this to default to the same dir as the render output
768  * to prevent saving to C:\ on Windows */
769
770 /* campbell: logic behind this...
771  *
772  * - if the ID is from a library, return library path
773  * - else if the file has been saved return the blend file path.
774  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
775  */
776 const char *modifier_path_relbase(Object *ob)
777 {
778         if (G.relbase_valid || ID_IS_LINKED(ob)) {
779                 return ID_BLEND_PATH(G.main, &ob->id);
780         }
781         else {
782                 /* last resort, better then using "" which resolves to the current
783                  * working directory */
784                 return BKE_tempdir_session();
785         }
786 }
787
788 /* initializes the path with either */
789 void modifier_path_init(char *path, int path_maxlen, const char *name)
790 {
791         /* elubie: changed this to default to the same dir as the render output
792          * to prevent saving to C:\ on Windows */
793         BLI_join_dirfile(path, path_maxlen,
794                          G.relbase_valid ? "//" : BKE_tempdir_session(),
795                          name);
796 }
797
798
799 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
800
801 struct DerivedMesh *modwrap_applyModifier(
802         ModifierData *md, const ModifierEvalContext *ctx,
803         struct DerivedMesh *dm)
804 {
805         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
806         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
807
808         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
809                 DM_ensure_normals(dm);
810         }
811         return modifier_applyModifier_DM_deprecated(md, ctx, dm);
812 }
813
814 struct DerivedMesh *modwrap_applyModifierEM(
815         ModifierData *md, const ModifierEvalContext *ctx,
816         struct BMEditMesh *em, DerivedMesh *dm)
817 {
818         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
819         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
820
821         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
822                 DM_ensure_normals(dm);
823         }
824         return modifier_applyModifierEM_DM_deprecated(md, ctx, em, dm);
825 }
826
827 void modwrap_deformVerts(
828         ModifierData *md, const ModifierEvalContext *ctx,
829         DerivedMesh *dm, float (*vertexCos)[3], int numVerts)
830 {
831         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
832         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
833
834         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
835                 DM_ensure_normals(dm);
836         }
837         modifier_deformVerts_DM_deprecated(md, ctx, dm, vertexCos, numVerts);
838 }
839
840 void modwrap_deformVertsEM(
841         ModifierData *md, const ModifierEvalContext *ctx,
842         struct BMEditMesh *em, DerivedMesh *dm,
843         float (*vertexCos)[3], int numVerts)
844 {
845         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
846         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
847
848         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
849                 DM_ensure_normals(dm);
850         }
851         modifier_deformVertsEM_DM_deprecated(md, ctx, em, dm, vertexCos, numVerts);
852 }
853 /* end modifier callback wrappers */
854
855
856 /* wrappers for modifier callbacks that accept Mesh and select the proper implementation
857  * depending on if the modifier has been ported to Mesh or is still using DerivedMesh
858  */
859
860 void modifier_deformVerts(struct ModifierData *md, const ModifierEvalContext *ctx,
861         struct Mesh *mesh,
862         float (*vertexCos)[3], int numVerts)
863 {
864         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
865
866         if (mti->deformVerts) {
867                 mti->deformVerts(md, ctx, mesh, vertexCos, numVerts);
868         }
869         else {
870                 DerivedMesh *dm = NULL;
871                 if (mesh) {
872                         dm = CDDM_from_mesh(mesh);
873                 }
874
875                 mti->deformVerts_DM(md, ctx, dm, vertexCos, numVerts);
876
877                 if (dm) {
878                         dm->release(dm);
879                 }
880         }
881 }
882
883 void modifier_deformMatrices(struct ModifierData *md, const ModifierEvalContext *ctx,
884         struct Mesh *mesh,
885         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
886 {
887         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
888
889         if (mti->deformMatrices) {
890                 mti->deformMatrices(md, ctx, mesh, vertexCos, defMats, numVerts);
891         }
892         else {
893                 DerivedMesh *dm = NULL;
894                 if (mesh) {
895                         dm = CDDM_from_mesh(mesh);
896                 }
897
898                 mti->deformMatrices_DM(md, ctx, dm, vertexCos, defMats, numVerts);
899
900                 if (dm) {
901                         dm->release(dm);
902                 }
903         }
904 }
905
906 void modifier_deformVertsEM(struct ModifierData *md, const ModifierEvalContext *ctx,
907         struct BMEditMesh *editData, struct Mesh *mesh,
908         float (*vertexCos)[3], int numVerts)
909 {
910         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
911
912         if (mti->deformVertsEM) {
913                 mti->deformVertsEM(md, ctx, editData, mesh, vertexCos, numVerts);
914         }
915         else {
916                 DerivedMesh *dm = NULL;
917                 if (mesh) {
918                         dm = CDDM_from_mesh(mesh);
919                 }
920
921                 mti->deformVertsEM_DM(md, ctx, editData, dm, vertexCos, numVerts);
922
923                 if (dm) {
924                         dm->release(dm);
925                 }
926         }
927 }
928
929 void modifier_deformMatricesEM(struct ModifierData *md, const ModifierEvalContext *ctx,
930         struct BMEditMesh *editData, struct Mesh *mesh,
931         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
932 {
933         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
934
935         if (mti->deformMatricesEM) {
936                 mti->deformMatricesEM(md, ctx, editData, mesh, vertexCos, defMats, numVerts);
937         }
938         else {
939                 DerivedMesh *dm = NULL;
940                 if (mesh) {
941                         dm = CDDM_from_mesh(mesh);
942                 }
943
944                 mti->deformMatricesEM_DM(md, ctx, editData, dm, vertexCos, defMats, numVerts);
945
946                 if (dm) {
947                         dm->release(dm);
948                 }
949         }
950 }
951
952 struct Mesh *modifier_applyModifier(struct ModifierData *md, const ModifierEvalContext *ctx,
953         struct Mesh *mesh)
954 {
955         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
956
957         if (mti->applyModifier) {
958                 return mti->applyModifier(md, ctx, mesh);
959         }
960         else {
961                 DerivedMesh *dm = CDDM_from_mesh(mesh);
962
963                 DerivedMesh *ndm = mti->applyModifier_DM(md, ctx, dm);
964
965                 if(ndm != dm) {
966                         dm->release(dm);
967                 }
968
969                 DM_to_mesh(ndm, mesh, ctx->object, CD_MASK_EVERYTHING, true);
970
971                 return mesh;
972         }
973 }
974
975 struct Mesh *modifier_applyModifierEM(struct ModifierData *md, const ModifierEvalContext *ctx,
976         struct BMEditMesh *editData,
977         struct Mesh *mesh)
978 {
979         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
980
981         if (mti->applyModifierEM) {
982                 return mti->applyModifierEM(md, ctx, editData, mesh);
983         }
984         else {
985                 DerivedMesh *dm = CDDM_from_mesh(mesh);
986
987                 DerivedMesh *ndm = mti->applyModifierEM_DM(md, ctx, editData, dm);
988
989                 if(ndm != dm) {
990                         dm->release(dm);
991                 }
992
993                 DM_to_mesh(ndm, mesh, ctx->object, CD_MASK_EVERYTHING, true);
994
995                 return mesh;
996         }
997 }
998
999 /* depricated variants of above that accept DerivedMesh */
1000
1001 void modifier_deformVerts_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1002         struct DerivedMesh *dm,
1003         float (*vertexCos)[3], int numVerts)
1004 {
1005         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1006
1007         if (mti->deformVerts_DM) {
1008                 mti->deformVerts_DM(md, ctx, dm, vertexCos, numVerts);
1009         }
1010         else {
1011                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1012                 Mesh *mesh = NULL;
1013                 if (dm != NULL) {
1014                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1015                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1016                 }
1017
1018                 mti->deformVerts(md, ctx, mesh, vertexCos, numVerts);
1019
1020                 if (mesh != NULL) {
1021                         BKE_id_free(NULL, mesh);
1022                 }
1023         }
1024 }
1025
1026 void modifier_deformMatrices_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1027         struct DerivedMesh *dm,
1028         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
1029 {
1030
1031         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1032
1033         if (mti->deformMatrices_DM) {
1034                 mti->deformMatrices_DM(md, ctx, dm, vertexCos, defMats, numVerts);
1035         }
1036         else {
1037                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1038                 Mesh *mesh = NULL;
1039                 if (dm != NULL) {
1040                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1041                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1042                 }
1043
1044                 mti->deformMatrices(md, ctx, mesh, vertexCos, defMats, numVerts);
1045
1046                 if (mesh != NULL) {
1047                         BKE_id_free(NULL, mesh);
1048                 }
1049         }
1050 }
1051
1052 void modifier_deformVertsEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1053         struct BMEditMesh *editData, struct DerivedMesh *dm,
1054         float (*vertexCos)[3], int numVerts)
1055 {
1056         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1057
1058         if (mti->deformVertsEM_DM) {
1059                 mti->deformVertsEM_DM(md, ctx, editData, dm, vertexCos, numVerts);
1060         }
1061         else {
1062                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1063                 Mesh *mesh = NULL;
1064                 if (dm != NULL) {
1065                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1066                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1067                 }
1068
1069                 mti->deformVertsEM(md, ctx, editData, mesh, vertexCos, numVerts);
1070
1071                 if (mesh != NULL) {
1072                         BKE_id_free(NULL, mesh);
1073                 }
1074         }
1075 }
1076
1077 void modifier_deformMatricesEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1078         struct BMEditMesh *editData, struct DerivedMesh *dm,
1079         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
1080 {
1081         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1082
1083         if (mti->deformMatricesEM_DM) {
1084                 mti->deformMatricesEM_DM(md, ctx, editData, dm, vertexCos, defMats, numVerts);
1085         }
1086         else {
1087                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1088                 Mesh *mesh = NULL;
1089                 if (dm != NULL) {
1090                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1091                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1092                 }
1093
1094                 mti->deformMatricesEM(md, ctx, editData, mesh, vertexCos, defMats, numVerts);
1095
1096                 if (mesh != NULL) {
1097                         BKE_id_free(NULL, mesh);
1098                 }
1099         }
1100 }
1101
1102 struct DerivedMesh *modifier_applyModifier_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1103         struct DerivedMesh *dm)
1104 {
1105         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1106
1107         if (mti->applyModifier_DM) {
1108                 return mti->applyModifier_DM(md, ctx, dm);
1109         }
1110         else {
1111                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1112                 Mesh *mesh = NULL;
1113                 if (dm != NULL) {
1114                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1115                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1116                 }
1117
1118                 struct Mesh *new_mesh = mti->applyModifier(md, ctx, mesh);
1119
1120                 /* Make a DM that doesn't reference new_mesh so we can free the latter. */
1121                 DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE);
1122
1123                 if(new_mesh != mesh) {
1124                         BKE_id_free(NULL, new_mesh);
1125                 }
1126                 if (mesh != NULL) {
1127                         BKE_id_free(NULL, mesh);
1128                 }
1129
1130                 return ndm;
1131         }
1132 }
1133
1134 struct DerivedMesh *modifier_applyModifierEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1135         struct BMEditMesh *editData,
1136         struct DerivedMesh *dm)
1137 {
1138         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1139
1140         if (mti->applyModifierEM_DM) {
1141                 return mti->applyModifierEM_DM(md, ctx, editData, dm);
1142         }
1143         else {
1144                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1145                 Mesh *mesh = NULL;
1146                 if (dm != NULL) {
1147                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1148                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1149                 }
1150
1151                 struct Mesh *new_mesh = mti->applyModifierEM(md, ctx, editData, mesh);
1152
1153                 /* Make a DM that doesn't reference new_mesh so we can free the latter. */
1154                 DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE);
1155
1156                 if(new_mesh != mesh) {
1157                         BKE_id_free(NULL, new_mesh);
1158                 }
1159                 if (mesh != NULL) {
1160                         BKE_id_free(NULL, mesh);
1161                 }
1162
1163                 return ndm;
1164         }
1165 }
1166