Merge branch 'blender2.7'
[blender.git] / source / blender / blenkernel / intern / modifier.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software  Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005 by the Blender Foundation.
17  * All rights reserved.
18  * Modifier stack implementation.
19  *
20  * BKE_modifier.h contains the function prototypes for this file.
21  */
22
23 /** \file \ingroup bke
24  */
25
26 #include <stdlib.h>
27 #include <stddef.h>
28 #include <string.h>
29 #include <stdarg.h>
30 #include <math.h>
31 #include <float.h>
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_armature_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_object_types.h"
38
39 #include "BLI_utildefines.h"
40 #include "BLI_listbase.h"
41 #include "BLI_linklist.h"
42 #include "BLI_path_util.h"
43 #include "BLI_string.h"
44 #include "BLI_string_utils.h"
45
46 #include "BLT_translation.h"
47
48 #include "BKE_appdir.h"
49 #include "BKE_cdderivedmesh.h"
50 #include "BKE_editmesh.h"
51 #include "BKE_global.h"
52 #include "BKE_idcode.h"
53 #include "BKE_key.h"
54 #include "BKE_library.h"
55 #include "BKE_library_query.h"
56 #include "BKE_mesh.h"
57 #include "BKE_multires.h"
58 #include "BKE_object.h"
59 #include "BKE_DerivedMesh.h"
60
61 /* may move these, only for modifier_path_relbase */
62 #include "BKE_main.h"
63 /* end */
64
65 #include "DEG_depsgraph.h"
66 #include "DEG_depsgraph_query.h"
67
68 #include "MOD_modifiertypes.h"
69
70 #include "CLG_log.h"
71
72 static CLG_LogRef LOG = {"bke.modifier"};
73 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
74 static VirtualModifierData virtualModifierCommonData;
75
76 void BKE_modifier_init(void)
77 {
78         ModifierData *md;
79
80         /* Initialize modifier types */
81         modifier_type_init(modifier_types); /* MOD_utils.c */
82
83         /* Initialize global cmmon storage used for virtual modifier list */
84         md = modifier_new(eModifierType_Armature);
85         virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
86         modifier_free(md);
87
88         md = modifier_new(eModifierType_Curve);
89         virtualModifierCommonData.cmd = *((CurveModifierData *) md);
90         modifier_free(md);
91
92         md = modifier_new(eModifierType_Lattice);
93         virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
94         modifier_free(md);
95
96         md = modifier_new(eModifierType_ShapeKey);
97         virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
98         modifier_free(md);
99
100         virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
101         virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
102         virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
103         virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
104 }
105
106 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
107 {
108         /* type unsigned, no need to check < 0 */
109         if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
110                 return modifier_types[type];
111         }
112         else {
113                 return NULL;
114         }
115 }
116
117 /***/
118
119 ModifierData *modifier_new(int type)
120 {
121         const ModifierTypeInfo *mti = modifierType_getInfo(type);
122         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
123
124         /* note, this name must be made unique later */
125         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
126
127         md->type = type;
128         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
129         md->flag = eModifierFlag_StaticOverride_Local;
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, const int UNUSED(flag))
287 {
288         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
289
290         /* md_dst may have already 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         target->flag = md->flag;
317
318         if (mti->copyData) {
319                 mti->copyData(md, target, flag);
320         }
321
322         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
323                 if (mti->foreachIDLink) {
324                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
325                 }
326                 else if (mti->foreachObjectLink) {
327                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
328                 }
329         }
330 }
331
332 void modifier_copyData(ModifierData *md, ModifierData *target)
333 {
334         modifier_copyData_ex(md, target, 0);
335 }
336
337
338 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
339 {
340         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
341
342         return ((!mti->isDisabled || !mti->isDisabled(scene, md, 0)) &&
343                 (mti->flags & eModifierTypeFlag_SupportsEditmode) &&
344                 modifier_supportsMapping(md));
345 }
346
347 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
348 {
349         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
350
351         return ((md->mode & eModifierMode_Realtime) &&
352                 (md->mode & eModifierMode_Editmode) &&
353                 (!mti->isDisabled || !mti->isDisabled(scene, md, 0)) &&
354                 modifier_supportsMapping(md));
355 }
356
357 bool modifier_isSameTopology(ModifierData *md)
358 {
359         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
360         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
361 }
362
363 bool modifier_isNonGeometrical(ModifierData *md)
364 {
365         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
366         return (mti->type == eModifierTypeType_NonGeometrical);
367 }
368
369 void modifier_setError(ModifierData *md, const char *_format, ...)
370 {
371         char buffer[512];
372         va_list ap;
373         const char *format = TIP_(_format);
374
375         va_start(ap, _format);
376         vsnprintf(buffer, sizeof(buffer), format, ap);
377         va_end(ap);
378         buffer[sizeof(buffer) - 1] = '\0';
379
380         if (md->error)
381                 MEM_freeN(md->error);
382
383         md->error = BLI_strdup(buffer);
384
385         CLOG_STR_ERROR(&LOG, md->error);
386 }
387
388 /* used for buttons, to find out if the 'draw deformed in editmode' option is
389  * there
390  *
391  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
392  * then is NULL)
393  * also used for some mesh tools to give warnings
394  */
395 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
396 {
397         VirtualModifierData virtualModifierData;
398         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
399         int i, cageIndex = -1;
400
401         if (r_lastPossibleCageIndex) {
402                 /* ensure the value is initialized */
403                 *r_lastPossibleCageIndex = -1;
404         }
405
406         /* Find the last modifier acting on the cage. */
407         for (i = 0; md; i++, md = md->next) {
408                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
409                 bool supports_mapping;
410
411                 if (mti->isDisabled && mti->isDisabled(scene, md, 0)) continue;
412                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
413                 if (md->mode & eModifierMode_DisableTemporary) continue;
414
415                 supports_mapping = modifier_supportsMapping(md);
416                 if (r_lastPossibleCageIndex && supports_mapping) {
417                         *r_lastPossibleCageIndex = i;
418                 }
419
420                 if (!(md->mode & eModifierMode_Realtime)) continue;
421                 if (!(md->mode & eModifierMode_Editmode)) continue;
422
423                 if (!supports_mapping)
424                         break;
425
426                 if (md->mode & eModifierMode_OnCage)
427                         cageIndex = i;
428         }
429
430         return cageIndex;
431 }
432
433
434 bool modifiers_isSoftbodyEnabled(Object *ob)
435 {
436         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
437
438         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
439 }
440
441 bool modifiers_isClothEnabled(Object *ob)
442 {
443         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
444
445         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
446 }
447
448 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
449 {
450         ModifierData *md = modifiers_findByType(ob, modifierType);
451
452         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
453 }
454
455 bool modifiers_isParticleEnabled(Object *ob)
456 {
457         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
458
459         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
460 }
461
462 /**
463  * Check whether is enabled.
464  *
465  * \param scene: Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
466  */
467 bool modifier_isEnabled(const struct Scene *scene, ModifierData *md, int required_mode)
468 {
469         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
470
471         if ((md->mode & required_mode) != required_mode) return false;
472         if (scene != NULL && mti->isDisabled && mti->isDisabled(scene, md, required_mode == eModifierMode_Render)) return false;
473         if (md->mode & eModifierMode_DisableTemporary) return false;
474         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
475
476         return true;
477 }
478
479 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
480                                     CustomDataMask dataMask, int required_mode,
481                                     ModifierData *previewmd, CustomDataMask previewmask)
482 {
483         CDMaskLink *dataMasks = NULL;
484         CDMaskLink *curr, *prev;
485
486         /* build a list of modifier data requirements in reverse order */
487         for (; md; md = md->next) {
488                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
489
490                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
491
492                 if (modifier_isEnabled(scene, md, required_mode)) {
493                         if (mti->requiredDataMask)
494                                 curr->mask = mti->requiredDataMask(ob, md);
495
496                         if (previewmd == md) {
497                                 curr->mask |= previewmask;
498                         }
499                 }
500
501                 /* prepend new datamask */
502                 curr->next = dataMasks;
503                 dataMasks = curr;
504         }
505
506         /* build the list of required data masks - each mask in the list must
507          * include all elements of the masks that follow it
508          *
509          * note the list is currently in reverse order, so "masks that follow it"
510          * actually means "masks that precede it" at the moment
511          */
512         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
513                 if (prev) {
514                         CustomDataMask prev_mask = prev->mask;
515                         CustomDataMask curr_mask = curr->mask;
516
517                         curr->mask = curr_mask | prev_mask;
518                 }
519                 else {
520                         CustomDataMask curr_mask = curr->mask;
521
522                         curr->mask = curr_mask | dataMask;
523                 }
524         }
525
526         /* reverse the list so it's in the correct order */
527         BLI_linklist_reverse((LinkNode **)&dataMasks);
528
529         return dataMasks;
530 }
531
532 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
533 {
534         ModifierData *tmp_md = NULL;
535
536         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
537                 return tmp_md;
538
539         /* Find the latest modifier in stack generating preview. */
540         for (; md; md = md->next) {
541                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
542                         tmp_md = md;
543         }
544         return tmp_md;
545 }
546
547 /* NOTE: This is to support old files from before Blender supported modifiers,
548  * in some cases versioning code updates these so for new files this will
549  * return an empty list. */
550 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
551 {
552         ModifierData *md;
553
554         md = ob->modifiers.first;
555
556         *virtualModifierData = virtualModifierCommonData;
557
558         if (ob->parent) {
559                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
560                         virtualModifierData->amd.object = ob->parent;
561                         virtualModifierData->amd.modifier.next = md;
562                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
563                         md = &virtualModifierData->amd.modifier;
564                 }
565                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
566                         virtualModifierData->cmd.object = ob->parent;
567                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
568                         virtualModifierData->cmd.modifier.next = md;
569                         md = &virtualModifierData->cmd.modifier;
570                 }
571                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
572                         virtualModifierData->lmd.object = ob->parent;
573                         virtualModifierData->lmd.modifier.next = md;
574                         md = &virtualModifierData->lmd.modifier;
575                 }
576         }
577
578         /* shape key modifier, not yet for curves */
579         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
580                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
581                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
582                 else
583                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
584
585                 virtualModifierData->smd.modifier.next = md;
586                 md = &virtualModifierData->smd.modifier;
587         }
588
589         return md;
590 }
591
592 /* Takes an object and returns its first selected armature, else just its armature
593  * This should work for multiple armatures per object
594  */
595 Object *modifiers_isDeformedByArmature(Object *ob)
596 {
597         VirtualModifierData virtualModifierData;
598         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
599         ArmatureModifierData *amd = NULL;
600
601         /* return the first selected armature, this lets us use multiple armatures */
602         for (; md; md = md->next) {
603                 if (md->type == eModifierType_Armature) {
604                         amd = (ArmatureModifierData *) md;
605                         if (amd->object && (amd->object->flag & SELECT))
606                                 return amd->object;
607                 }
608         }
609
610         if (amd) /* if were still here then return the last armature */
611                 return amd->object;
612
613         return NULL;
614 }
615
616 Object *modifiers_isDeformedByMeshDeform(Object *ob)
617 {
618         VirtualModifierData virtualModifierData;
619         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
620         MeshDeformModifierData *mdmd = NULL;
621
622         /* return the first selected armature, this lets us use multiple armatures */
623         for (; md; md = md->next) {
624                 if (md->type == eModifierType_MeshDeform) {
625                         mdmd = (MeshDeformModifierData *) md;
626                         if (mdmd->object && (mdmd->object->flag & SELECT))
627                                 return mdmd->object;
628                 }
629         }
630
631         if (mdmd) /* if were still here then return the last armature */
632                 return mdmd->object;
633
634         return NULL;
635 }
636
637 /* Takes an object and returns its first selected lattice, else just its lattice
638  * This should work for multiple lattices per object
639  */
640 Object *modifiers_isDeformedByLattice(Object *ob)
641 {
642         VirtualModifierData virtualModifierData;
643         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
644         LatticeModifierData *lmd = NULL;
645
646         /* return the first selected lattice, this lets us use multiple lattices */
647         for (; md; md = md->next) {
648                 if (md->type == eModifierType_Lattice) {
649                         lmd = (LatticeModifierData *) md;
650                         if (lmd->object && (lmd->object->flag & SELECT))
651                                 return lmd->object;
652                 }
653         }
654
655         if (lmd) /* if were still here then return the last lattice */
656                 return lmd->object;
657
658         return NULL;
659 }
660
661 /* Takes an object and returns its first selected curve, else just its curve
662  * This should work for multiple curves per object
663  */
664 Object *modifiers_isDeformedByCurve(Object *ob)
665 {
666         VirtualModifierData virtualModifierData;
667         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
668         CurveModifierData *cmd = NULL;
669
670         /* return the first selected curve, this lets us use multiple curves */
671         for (; md; md = md->next) {
672                 if (md->type == eModifierType_Curve) {
673                         cmd = (CurveModifierData *) md;
674                         if (cmd->object && (cmd->object->flag & SELECT))
675                                 return cmd->object;
676                 }
677         }
678
679         if (cmd) /* if were still here then return the last curve */
680                 return cmd->object;
681
682         return NULL;
683 }
684
685 bool modifiers_usesArmature(Object *ob, bArmature *arm)
686 {
687         VirtualModifierData virtualModifierData;
688         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
689
690         for (; md; md = md->next) {
691                 if (md->type == eModifierType_Armature) {
692                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
693                         if (amd->object && amd->object->data == arm)
694                                 return true;
695                 }
696         }
697
698         return false;
699 }
700
701 bool modifier_isCorrectableDeformed(ModifierData *md)
702 {
703         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
704         return mti->deformMatricesEM != NULL;
705 }
706
707 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
708 {
709         VirtualModifierData virtualModifierData;
710         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
711         int required_mode = eModifierMode_Realtime;
712
713         if (ob->mode == OB_MODE_EDIT) {
714                 required_mode |= eModifierMode_Editmode;
715         }
716         for (; md; md = md->next) {
717                 if (!modifier_isEnabled(scene, md, required_mode)) {
718                         /* pass */
719                 }
720                 else if (modifier_isCorrectableDeformed(md)) {
721                         return true;
722                 }
723         }
724         return false;
725 }
726
727 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
728  * to preview something... Used by DynamicPaint and WeightVG currently. */
729 bool modifiers_isPreview(Object *ob)
730 {
731         ModifierData *md = ob->modifiers.first;
732
733         for (; md; md = md->next) {
734                 if (modifier_isPreview(md))
735                         return true;
736         }
737
738         return false;
739 }
740
741 void modifier_freeTemporaryData(ModifierData *md)
742 {
743         if (md->type == eModifierType_Armature) {
744                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
745
746                 if (amd->prevCos) {
747                         MEM_freeN(amd->prevCos);
748                         amd->prevCos = NULL;
749                 }
750         }
751 }
752
753 /* ensure modifier correctness when changing ob->data */
754 void test_object_modifiers(Object *ob)
755 {
756         ModifierData *md;
757
758         /* just multires checked for now, since only multires
759          * modifies mesh data */
760
761         if (ob->type != OB_MESH) return;
762
763         for (md = ob->modifiers.first; md; md = md->next) {
764                 if (md->type == eModifierType_Multires) {
765                         MultiresModifierData *mmd = (MultiresModifierData *)md;
766
767                         multiresModifier_set_levels_from_disps(mmd, ob);
768                 }
769         }
770 }
771
772 /* where should this go?, it doesn't fit well anywhere :S - campbell */
773
774 /* elubie: changed this to default to the same dir as the render output
775  * to prevent saving to C:\ on Windows */
776
777 /* campbell: logic behind this...
778  *
779  * - if the ID is from a library, return library path
780  * - else if the file has been saved return the blend file path.
781  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
782  */
783 const char *modifier_path_relbase(Main *bmain, Object *ob)
784 {
785         if (G.relbase_valid || ID_IS_LINKED(ob)) {
786                 return ID_BLEND_PATH(bmain, &ob->id);
787         }
788         else {
789                 /* last resort, better then using "" which resolves to the current
790                  * working directory */
791                 return BKE_tempdir_session();
792         }
793 }
794
795 const char *modifier_path_relbase_from_global(Object *ob)
796 {
797         if (G.relbase_valid || ID_IS_LINKED(ob)) {
798                 return ID_BLEND_PATH_FROM_GLOBAL(&ob->id);
799         }
800         else {
801                 /* last resort, better then using "" which resolves to the current
802                  * working directory */
803                 return BKE_tempdir_session();
804         }
805 }
806
807 /* initializes the path with either */
808 void modifier_path_init(char *path, int path_maxlen, const char *name)
809 {
810         /* elubie: changed this to default to the same dir as the render output
811          * to prevent saving to C:\ on Windows */
812         BLI_join_dirfile(path, path_maxlen,
813                          G.relbase_valid ? "//" : BKE_tempdir_session(),
814                          name);
815 }
816
817
818 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
819
820 struct Mesh *modwrap_applyModifier(
821         ModifierData *md, const ModifierEvalContext *ctx,
822         struct Mesh *me)
823 {
824         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
825         BLI_assert(CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
826
827         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
828                 BKE_mesh_calc_normals(me);
829         }
830         return mti->applyModifier(md, ctx, me);
831 }
832
833 void modwrap_deformVerts(
834         ModifierData *md, const ModifierEvalContext *ctx,
835         Mesh *me, float (*vertexCos)[3], int numVerts)
836 {
837         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
838         BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
839
840         if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
841                 BKE_mesh_calc_normals(me);
842         }
843         mti->deformVerts(md, ctx, me, vertexCos, numVerts);
844 }
845
846 void modwrap_deformVertsEM(
847         ModifierData *md, const ModifierEvalContext *ctx,
848         struct BMEditMesh *em, Mesh *me,
849         float (*vertexCos)[3], int numVerts)
850 {
851         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
852         BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
853
854         if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
855                 BKE_mesh_calc_normals(me);
856         }
857         mti->deformVertsEM(md, ctx, em, me, vertexCos, numVerts);
858 }
859
860 /* end modifier callback wrappers */
861
862
863 /* wrappers for modifier callbacks that accept Mesh and select the proper implementation
864  * depending on if the modifier has been ported to Mesh or is still using DerivedMesh
865  */
866
867 /* deprecated variants of above that accept DerivedMesh */
868
869 struct DerivedMesh *modifier_applyModifier_DM_deprecated(
870         struct ModifierData *md, const ModifierEvalContext *ctx,
871         struct DerivedMesh *dm)
872 {
873         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
874
875         /* TODO(sybren): deduplicate all the copies of this code in this file. */
876         Mesh *mesh = NULL;
877         if (dm != NULL) {
878                 mesh = BKE_id_new_nomain(ID_ME, NULL);
879                 DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
880         }
881
882         struct Mesh *new_mesh = mti->applyModifier(md, ctx, mesh);
883
884         /* Make a DM that doesn't reference new_mesh so we can free the latter. */
885         DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE, CD_MASK_EVERYTHING);
886
887         if (new_mesh != mesh) {
888                 BKE_id_free(NULL, new_mesh);
889         }
890         if (mesh != NULL) {
891                 BKE_id_free(NULL, mesh);
892         }
893
894         return ndm;
895
896 }
897
898 /**
899  * Get evaluated mesh for other evaluated object, which is used as an operand for the modifier,
900  * e.g. second operand for boolean modifier.
901  * Note that modifiers in stack always get fully evaluated COW ID pointers, never original ones. Makes things simpler.
902  *
903  * \param get_cage_mesh Return evaluated mesh with only deforming modifiers applied
904  *                      (i.e. mesh topology remains the same as original one, a.k.a. 'cage' mesh).
905  */
906 Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval, const bool get_cage_mesh)
907 {
908         Mesh *me = NULL;
909
910         if ((ob_eval->type == OB_MESH) && (ob_eval->mode & OB_MODE_EDIT)) {
911                 /* In EditMode, evaluated mesh is stored in BMEditMesh, not the object... */
912                 BMEditMesh *em = BKE_editmesh_from_object(ob_eval);
913                 if (em != NULL) {  /* em might not exist yet in some cases, just after loading a .blend file, see T57878. */
914                         me = (get_cage_mesh && em->mesh_eval_cage != NULL) ? em->mesh_eval_cage : em->mesh_eval_final;
915                 }
916         }
917         if (me == NULL) {
918                 me = (get_cage_mesh && ob_eval->runtime.mesh_deform_eval != NULL) ? ob_eval->runtime.mesh_deform_eval :
919                                                                                     ob_eval->runtime.mesh_eval;
920         }
921
922         return me;
923 }