Fix (unreported) memleak when copying object with some modifiers.
[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_object_types.h"
50
51 #include "BLI_utildefines.h"
52 #include "BLI_listbase.h"
53 #include "BLI_linklist.h"
54 #include "BLI_path_util.h"
55 #include "BLI_string.h"
56 #include "BLI_string_utils.h"
57
58 #include "BLT_translation.h"
59
60 #include "BKE_appdir.h"
61 #include "BKE_key.h"
62 #include "BKE_library.h"
63 #include "BKE_library_query.h"
64 #include "BKE_multires.h"
65 #include "BKE_DerivedMesh.h"
66
67 /* may move these, only for modifier_path_relbase */
68 #include "BKE_global.h" /* ugh, G.main->name only */
69 #include "BKE_main.h"
70 /* end */
71
72 #include "MOD_modifiertypes.h"
73
74 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
75 static VirtualModifierData virtualModifierCommonData;
76
77 void BKE_modifier_init(void)
78 {
79         ModifierData *md;
80
81         /* Initialize modifier types */
82         modifier_type_init(modifier_types); /* MOD_utils.c */
83
84         /* Initialize global cmmon storage used for virtual modifier list */
85         md = modifier_new(eModifierType_Armature);
86         virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
87         modifier_free(md);
88
89         md = modifier_new(eModifierType_Curve);
90         virtualModifierCommonData.cmd = *((CurveModifierData *) md);
91         modifier_free(md);
92
93         md = modifier_new(eModifierType_Lattice);
94         virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
95         modifier_free(md);
96
97         md = modifier_new(eModifierType_ShapeKey);
98         virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
99         modifier_free(md);
100
101         virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
102         virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
103         virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
104         virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
105 }
106
107 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
108 {
109         /* type unsigned, no need to check < 0 */
110         if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
111                 return modifier_types[type];
112         }
113         else {
114                 return NULL;
115         }
116 }
117
118 /***/
119
120 ModifierData *modifier_new(int type)
121 {
122         const ModifierTypeInfo *mti = modifierType_getInfo(type);
123         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
124         
125         /* note, this name must be made unique later */
126         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
127
128         md->type = type;
129         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
130
131         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
132                 md->mode |= eModifierMode_Editmode;
133
134         if (mti->initData) mti->initData(md);
135
136         return md;
137 }
138
139 static void modifier_free_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
140 {
141         ID *id = *idpoin;
142         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
143                 id_us_min(id);
144         }
145 }
146
147 void modifier_free_ex(ModifierData *md, const int flag)
148 {
149         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
150
151         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
152                 if (mti->foreachIDLink) {
153                         mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
154                 }
155                 else if (mti->foreachObjectLink) {
156                         mti->foreachObjectLink(md, NULL, (ObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
157                 }
158         }
159
160         if (mti->freeData) mti->freeData(md);
161         if (md->error) MEM_freeN(md->error);
162
163         MEM_freeN(md);
164 }
165
166 void modifier_free(ModifierData *md)
167 {
168         modifier_free_ex(md, 0);
169 }
170
171 bool modifier_unique_name(ListBase *modifiers, ModifierData *md)
172 {
173         if (modifiers && md) {
174                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
175
176                 return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
177         }
178         return false;
179 }
180
181 bool modifier_dependsOnTime(ModifierData *md)
182 {
183         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
184
185         return mti->dependsOnTime && mti->dependsOnTime(md);
186 }
187
188 bool modifier_supportsMapping(ModifierData *md)
189 {
190         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
191
192         return (mti->type == eModifierTypeType_OnlyDeform ||
193                 (mti->flags & eModifierTypeFlag_SupportsMapping));
194 }
195
196 bool modifier_isPreview(ModifierData *md)
197 {
198         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
199
200         /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
201         if (!((mti->flags & eModifierTypeFlag_UsesPreview) || (mti->type == eModifierTypeType_Constructive))) {
202                 return false;
203         }
204
205         if (md->mode & eModifierMode_Realtime) {
206                 return true;
207         }
208
209         return false;
210 }
211
212 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
213 {
214         ModifierData *md = ob->modifiers.first;
215
216         for (; md; md = md->next)
217                 if (md->type == type)
218                         break;
219
220         return md;
221 }
222
223 ModifierData *modifiers_findByName(Object *ob, const char *name)
224 {
225         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
226 }
227
228 void modifiers_clearErrors(Object *ob)
229 {
230         ModifierData *md = ob->modifiers.first;
231         /* int qRedraw = 0; */
232
233         for (; md; md = md->next) {
234                 if (md->error) {
235                         MEM_freeN(md->error);
236                         md->error = NULL;
237
238                         /* qRedraw = 1; */
239                 }
240         }
241 }
242
243 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, void *userData)
244 {
245         ModifierData *md = ob->modifiers.first;
246
247         for (; md; md = md->next) {
248                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
249
250                 if (mti->foreachObjectLink)
251                         mti->foreachObjectLink(md, ob, walk, userData);
252         }
253 }
254
255 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
256 {
257         ModifierData *md = ob->modifiers.first;
258
259         for (; md; md = md->next) {
260                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
261
262                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
263                 else if (mti->foreachObjectLink) {
264                         /* each Object can masquerade as an ID, so this should be OK */
265                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
266                         mti->foreachObjectLink(md, ob, fp, userData);
267                 }
268         }
269 }
270
271 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
272 {
273         ModifierData *md = ob->modifiers.first;
274
275         for (; md; md = md->next) {
276                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
277
278                 if (mti->foreachTexLink)
279                         mti->foreachTexLink(md, ob, walk, userData);
280         }
281 }
282
283 /* callback's can use this
284  * to avoid copying every member.
285  */
286 void modifier_copyData_generic(const ModifierData *md_src, ModifierData *md_dst)
287 {
288         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
289
290         /* md_dst may have alredy be fully initialized with some extra allocated data,
291          * we need to free it now to avoid memleak. */
292         if (mti->freeData) {
293                 mti->freeData(md_dst);
294         }
295
296         const size_t data_size = sizeof(ModifierData);
297         const char *md_src_data = ((const char *)md_src) + data_size;
298         char       *md_dst_data =       ((char *)md_dst) + data_size;
299         BLI_assert(data_size <= (size_t)mti->structSize);
300         memcpy(md_dst_data, md_src_data, (size_t)mti->structSize - data_size);
301 }
302
303 static void modifier_copy_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
304 {
305         ID *id = *idpoin;
306         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
307                 id_us_plus(id);
308         }
309 }
310
311 void modifier_copyData_ex(ModifierData *md, ModifierData *target, const int flag)
312 {
313         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
314
315         target->mode = md->mode;
316
317         if (mti->copyData) {
318                 mti->copyData(md, target);
319         }
320
321         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
322                 if (mti->foreachIDLink) {
323                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
324                 }
325                 else if (mti->foreachObjectLink) {
326                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
327                 }
328         }
329 }
330
331 void modifier_copyData(ModifierData *md, ModifierData *target)
332 {
333         modifier_copyData_ex(md, target, 0);
334 }
335
336
337 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
338 {
339         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
340
341         md->scene = scene;
342
343         return ((!mti->isDisabled || !mti->isDisabled(md, 0)) &&
344                 (mti->flags & eModifierTypeFlag_SupportsEditmode) &&
345                 modifier_supportsMapping(md));
346 }
347
348 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
349 {
350         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
351
352         md->scene = scene;
353
354         return ((md->mode & eModifierMode_Realtime) &&
355                 (md->mode & eModifierMode_Editmode) &&
356                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
357                 modifier_supportsMapping(md));
358 }
359
360 bool modifier_isSameTopology(ModifierData *md)
361 {
362         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
363         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
364 }
365
366 bool modifier_isNonGeometrical(ModifierData *md)
367 {
368         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
369         return (mti->type == eModifierTypeType_NonGeometrical);
370 }
371
372 void modifier_setError(ModifierData *md, const char *_format, ...)
373 {
374         char buffer[512];
375         va_list ap;
376         const char *format = TIP_(_format);
377
378         va_start(ap, _format);
379         vsnprintf(buffer, sizeof(buffer), format, ap);
380         va_end(ap);
381         buffer[sizeof(buffer) - 1] = '\0';
382
383         if (md->error)
384                 MEM_freeN(md->error);
385
386         md->error = BLI_strdup(buffer);
387
388 }
389
390 /* used for buttons, to find out if the 'draw deformed in editmode' option is
391  * there
392  * 
393  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
394  * then is NULL) 
395  * also used for some mesh tools to give warnings
396  */
397 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
398 {
399         VirtualModifierData virtualModifierData;
400         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
401         int i, cageIndex = -1;
402
403         if (r_lastPossibleCageIndex) {
404                 /* ensure the value is initialized */
405                 *r_lastPossibleCageIndex = -1;
406         }
407
408         /* Find the last modifier acting on the cage. */
409         for (i = 0; md; i++, md = md->next) {
410                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
411                 bool supports_mapping;
412
413                 md->scene = scene;
414
415                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
416                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
417                 if (md->mode & eModifierMode_DisableTemporary) continue;
418
419                 supports_mapping = modifier_supportsMapping(md);
420                 if (r_lastPossibleCageIndex && supports_mapping) {
421                         *r_lastPossibleCageIndex = i;
422                 }
423
424                 if (!(md->mode & eModifierMode_Realtime)) continue;
425                 if (!(md->mode & eModifierMode_Editmode)) continue;
426
427                 if (!supports_mapping)
428                         break;
429
430                 if (md->mode & eModifierMode_OnCage)
431                         cageIndex = i;
432         }
433
434         return cageIndex;
435 }
436
437
438 bool modifiers_isSoftbodyEnabled(Object *ob)
439 {
440         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
441
442         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
443 }
444
445 bool modifiers_isClothEnabled(Object *ob)
446 {
447         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
448
449         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
450 }
451
452 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
453 {
454         ModifierData *md = modifiers_findByType(ob, modifierType);
455
456         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
457 }
458
459 bool modifiers_isParticleEnabled(Object *ob)
460 {
461         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
462
463         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
464 }
465
466 /**
467  * Check whether is enabled.
468  *
469  * \param scene Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
470  */
471 bool modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
472 {
473         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
474
475         md->scene = scene;
476
477         if ((md->mode & required_mode) != required_mode) return false;
478         if (scene != NULL && mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return false;
479         if (md->mode & eModifierMode_DisableTemporary) return false;
480         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
481         
482         return true;
483 }
484
485 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
486                                     CustomDataMask dataMask, int required_mode,
487                                     ModifierData *previewmd, CustomDataMask previewmask)
488 {
489         CDMaskLink *dataMasks = NULL;
490         CDMaskLink *curr, *prev;
491
492         /* build a list of modifier data requirements in reverse order */
493         for (; md; md = md->next) {
494                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
495
496                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
497                 
498                 if (modifier_isEnabled(scene, md, required_mode)) {
499                         if (mti->requiredDataMask)
500                                 curr->mask = mti->requiredDataMask(ob, md);
501
502                         if (previewmd == md) {
503                                 curr->mask |= previewmask;
504                         }
505                 }
506
507                 /* prepend new datamask */
508                 curr->next = dataMasks;
509                 dataMasks = curr;
510         }
511
512         /* build the list of required data masks - each mask in the list must
513          * include all elements of the masks that follow it
514          *
515          * note the list is currently in reverse order, so "masks that follow it"
516          * actually means "masks that precede it" at the moment
517          */
518         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
519                 if (prev) {
520                         CustomDataMask prev_mask = prev->mask;
521                         CustomDataMask curr_mask = curr->mask;
522
523                         curr->mask = curr_mask | prev_mask;
524                 }
525                 else {
526                         CustomDataMask curr_mask = curr->mask;
527
528                         curr->mask = curr_mask | dataMask;
529                 }
530         }
531
532         /* reverse the list so it's in the correct order */
533         BLI_linklist_reverse((LinkNode **)&dataMasks);
534
535         return dataMasks;
536 }
537
538 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
539 {
540         ModifierData *tmp_md = NULL;
541
542         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
543                 return tmp_md;
544
545         /* Find the latest modifier in stack generating preview. */
546         for (; md; md = md->next) {
547                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
548                         tmp_md = md;
549         }
550         return tmp_md;
551 }
552
553 /* NOTE: This is to support old files from before Blender supported modifiers,
554  * in some cases versioning code updates these so for new files this will
555  * return an empty list. */
556 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
557 {
558         ModifierData *md;
559
560         md = ob->modifiers.first;
561
562         *virtualModifierData = virtualModifierCommonData;
563
564         if (ob->parent) {
565                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
566                         virtualModifierData->amd.object = ob->parent;
567                         virtualModifierData->amd.modifier.next = md;
568                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
569                         md = &virtualModifierData->amd.modifier;
570                 }
571                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
572                         virtualModifierData->cmd.object = ob->parent;
573                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
574                         virtualModifierData->cmd.modifier.next = md;
575                         md = &virtualModifierData->cmd.modifier;
576                 }
577                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
578                         virtualModifierData->lmd.object = ob->parent;
579                         virtualModifierData->lmd.modifier.next = md;
580                         md = &virtualModifierData->lmd.modifier;
581                 }
582         }
583
584         /* shape key modifier, not yet for curves */
585         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
586                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
587                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
588                 else
589                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
590
591                 virtualModifierData->smd.modifier.next = md;
592                 md = &virtualModifierData->smd.modifier;
593         }
594
595         return md;
596 }
597
598 /* Takes an object and returns its first selected armature, else just its armature
599  * This should work for multiple armatures per object
600  */
601 Object *modifiers_isDeformedByArmature(Object *ob)
602 {
603         VirtualModifierData virtualModifierData;
604         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
605         ArmatureModifierData *amd = NULL;
606         
607         /* return the first selected armature, this lets us use multiple armatures */
608         for (; md; md = md->next) {
609                 if (md->type == eModifierType_Armature) {
610                         amd = (ArmatureModifierData *) md;
611                         if (amd->object && (amd->object->flag & SELECT))
612                                 return amd->object;
613                 }
614         }
615         
616         if (amd) /* if were still here then return the last armature */
617                 return amd->object;
618         
619         return NULL;
620 }
621
622 /* Takes an object and returns its first selected lattice, else just its lattice
623  * This should work for multiple lattices per object
624  */
625 Object *modifiers_isDeformedByLattice(Object *ob)
626 {
627         VirtualModifierData virtualModifierData;
628         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
629         LatticeModifierData *lmd = NULL;
630         
631         /* return the first selected lattice, this lets us use multiple lattices */
632         for (; md; md = md->next) {
633                 if (md->type == eModifierType_Lattice) {
634                         lmd = (LatticeModifierData *) md;
635                         if (lmd->object && (lmd->object->flag & SELECT))
636                                 return lmd->object;
637                 }
638         }
639         
640         if (lmd) /* if were still here then return the last lattice */
641                 return lmd->object;
642         
643         return NULL;
644 }
645
646 /* Takes an object and returns its first selected curve, else just its curve
647  * This should work for multiple curves per object
648  */
649 Object *modifiers_isDeformedByCurve(Object *ob)
650 {
651         VirtualModifierData virtualModifierData;
652         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
653         CurveModifierData *cmd = NULL;
654         
655         /* return the first selected curve, this lets us use multiple curves */
656         for (; md; md = md->next) {
657                 if (md->type == eModifierType_Curve) {
658                         cmd = (CurveModifierData *) md;
659                         if (cmd->object && (cmd->object->flag & SELECT))
660                                 return cmd->object;
661                 }
662         }
663         
664         if (cmd) /* if were still here then return the last curve */
665                 return cmd->object;
666         
667         return NULL;
668 }
669
670 bool modifiers_usesArmature(Object *ob, bArmature *arm)
671 {
672         VirtualModifierData virtualModifierData;
673         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
674
675         for (; md; md = md->next) {
676                 if (md->type == eModifierType_Armature) {
677                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
678                         if (amd->object && amd->object->data == arm)
679                                 return true;
680                 }
681         }
682
683         return false;
684 }
685
686 bool modifier_isCorrectableDeformed(ModifierData *md)
687 {
688         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
689         return (mti->deformMatricesEM != NULL);
690 }
691
692 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
693 {
694         VirtualModifierData virtualModifierData;
695         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
696         int required_mode = eModifierMode_Realtime;
697
698         if (ob->mode == OB_MODE_EDIT)
699                 required_mode |= eModifierMode_Editmode;
700         
701         for (; md; md = md->next) {
702                 if (!modifier_isEnabled(scene, md, required_mode)) {
703                         /* pass */
704                 }
705                 else if (modifier_isCorrectableDeformed(md)) {
706                         return true;
707                 }
708         }
709         return false;
710 }
711
712 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
713  * to preview something... Used by DynamicPaint and WeightVG currently. */
714 bool modifiers_isPreview(Object *ob)
715 {
716         ModifierData *md = ob->modifiers.first;
717
718         for (; md; md = md->next) {
719                 if (modifier_isPreview(md))
720                         return true;
721         }
722
723         return false;
724 }
725
726 void modifier_freeTemporaryData(ModifierData *md)
727 {
728         if (md->type == eModifierType_Armature) {
729                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
730
731                 if (amd->prevCos) {
732                         MEM_freeN(amd->prevCos);
733                         amd->prevCos = NULL;
734                 }
735         }
736 }
737
738 /* ensure modifier correctness when changing ob->data */
739 void test_object_modifiers(Object *ob)
740 {
741         ModifierData *md;
742
743         /* just multires checked for now, since only multires
744          * modifies mesh data */
745
746         if (ob->type != OB_MESH) return;
747
748         for (md = ob->modifiers.first; md; md = md->next) {
749                 if (md->type == eModifierType_Multires) {
750                         MultiresModifierData *mmd = (MultiresModifierData *)md;
751
752                         multiresModifier_set_levels_from_disps(mmd, ob);
753                 }
754         }
755 }
756
757 /* where should this go?, it doesnt fit well anywhere :S - campbell */
758
759 /* elubie: changed this to default to the same dir as the render output
760  * to prevent saving to C:\ on Windows */
761
762 /* campbell: logic behind this...
763  *
764  * - if the ID is from a library, return library path
765  * - else if the file has been saved return the blend file path.
766  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
767  */
768 const char *modifier_path_relbase(Object *ob)
769 {
770         if (G.relbase_valid || ID_IS_LINKED(ob)) {
771                 return ID_BLEND_PATH(G.main, &ob->id);
772         }
773         else {
774                 /* last resort, better then using "" which resolves to the current
775                  * working directory */
776                 return BKE_tempdir_session();
777         }
778 }
779
780 /* initializes the path with either */
781 void modifier_path_init(char *path, int path_maxlen, const char *name)
782 {
783         /* elubie: changed this to default to the same dir as the render output
784          * to prevent saving to C:\ on Windows */
785         BLI_join_dirfile(path, path_maxlen,
786                          G.relbase_valid ? "//" : BKE_tempdir_session(),
787                          name);
788 }
789
790
791 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
792
793 struct DerivedMesh *modwrap_applyModifier(
794         ModifierData *md, Object *ob,
795         struct DerivedMesh *dm,
796         ModifierApplyFlag flag)
797 {
798         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
799         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
800
801         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
802                 DM_ensure_normals(dm);
803         }
804         return mti->applyModifier(md, ob, dm, flag);
805 }
806
807 struct DerivedMesh *modwrap_applyModifierEM(
808         ModifierData *md, Object *ob,
809         struct BMEditMesh *em,
810         DerivedMesh *dm,
811         ModifierApplyFlag flag)
812 {
813         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
814         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
815
816         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
817                 DM_ensure_normals(dm);
818         }
819         return mti->applyModifierEM(md, ob, em, dm, flag);
820 }
821
822 void modwrap_deformVerts(
823         ModifierData *md, Object *ob,
824         DerivedMesh *dm,
825         float (*vertexCos)[3], int numVerts,
826         ModifierApplyFlag flag)
827 {
828         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
829         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
830
831         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
832                 DM_ensure_normals(dm);
833         }
834         mti->deformVerts(md, ob, dm, vertexCos, numVerts, flag);
835 }
836
837 void modwrap_deformVertsEM(
838         ModifierData *md, Object *ob,
839         struct BMEditMesh *em, DerivedMesh *dm,
840         float (*vertexCos)[3], int numVerts)
841 {
842         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
843         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
844
845         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
846                 DM_ensure_normals(dm);
847         }
848         mti->deformVertsEM(md, ob, em, dm, vertexCos, numVerts);
849 }
850 /* end modifier callback wrappers */