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
24  * \ingroup bke
25  */
26
27 #include <stdlib.h>
28 #include <stddef.h>
29 #include <string.h>
30 #include <stdarg.h>
31 #include <math.h>
32 #include <float.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_armature_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_object_types.h"
39
40 #include "BLI_utildefines.h"
41 #include "BLI_listbase.h"
42 #include "BLI_linklist.h"
43 #include "BLI_path_util.h"
44 #include "BLI_string.h"
45 #include "BLI_string_utils.h"
46
47 #include "BLT_translation.h"
48
49 #include "BKE_appdir.h"
50 #include "BKE_cdderivedmesh.h"
51 #include "BKE_editmesh.h"
52 #include "BKE_global.h"
53 #include "BKE_idcode.h"
54 #include "BKE_key.h"
55 #include "BKE_library.h"
56 #include "BKE_library_query.h"
57 #include "BKE_mesh.h"
58 #include "BKE_multires.h"
59 #include "BKE_object.h"
60 #include "BKE_DerivedMesh.h"
61
62 /* may move these, only for modifier_path_relbase */
63 #include "BKE_main.h"
64 /* end */
65
66 #include "DEG_depsgraph.h"
67 #include "DEG_depsgraph_query.h"
68
69 #include "MOD_modifiertypes.h"
70
71 #include "CLG_log.h"
72
73 static CLG_LogRef LOG = {"bke.modifier"};
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         md->flag = eModifierFlag_StaticOverride_Local;
131
132         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
133                 md->mode |= eModifierMode_Editmode;
134
135         if (mti->initData) mti->initData(md);
136
137         return md;
138 }
139
140 static void modifier_free_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
141 {
142         ID *id = *idpoin;
143         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
144                 id_us_min(id);
145         }
146 }
147
148 void modifier_free_ex(ModifierData *md, const int flag)
149 {
150         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
151
152         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
153                 if (mti->foreachIDLink) {
154                         mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
155                 }
156                 else if (mti->foreachObjectLink) {
157                         mti->foreachObjectLink(md, NULL, (ObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
158                 }
159         }
160
161         if (mti->freeData) mti->freeData(md);
162         if (md->error) MEM_freeN(md->error);
163
164         MEM_freeN(md);
165 }
166
167 void modifier_free(ModifierData *md)
168 {
169         modifier_free_ex(md, 0);
170 }
171
172 bool modifier_unique_name(ListBase *modifiers, ModifierData *md)
173 {
174         if (modifiers && md) {
175                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
176
177                 return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
178         }
179         return false;
180 }
181
182 bool modifier_dependsOnTime(ModifierData *md)
183 {
184         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
185
186         return mti->dependsOnTime && mti->dependsOnTime(md);
187 }
188
189 bool modifier_supportsMapping(ModifierData *md)
190 {
191         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
192
193         return (mti->type == eModifierTypeType_OnlyDeform ||
194                 (mti->flags & eModifierTypeFlag_SupportsMapping));
195 }
196
197 bool modifier_isPreview(ModifierData *md)
198 {
199         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
200
201         /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
202         if (!((mti->flags & eModifierTypeFlag_UsesPreview) || (mti->type == eModifierTypeType_Constructive))) {
203                 return false;
204         }
205
206         if (md->mode & eModifierMode_Realtime) {
207                 return true;
208         }
209
210         return false;
211 }
212
213 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
214 {
215         ModifierData *md = ob->modifiers.first;
216
217         for (; md; md = md->next)
218                 if (md->type == type)
219                         break;
220
221         return md;
222 }
223
224 ModifierData *modifiers_findByName(Object *ob, const char *name)
225 {
226         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
227 }
228
229 void modifiers_clearErrors(Object *ob)
230 {
231         ModifierData *md = ob->modifiers.first;
232         /* int qRedraw = 0; */
233
234         for (; md; md = md->next) {
235                 if (md->error) {
236                         MEM_freeN(md->error);
237                         md->error = NULL;
238
239                         /* qRedraw = 1; */
240                 }
241         }
242 }
243
244 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, void *userData)
245 {
246         ModifierData *md = ob->modifiers.first;
247
248         for (; md; md = md->next) {
249                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
250
251                 if (mti->foreachObjectLink)
252                         mti->foreachObjectLink(md, ob, walk, userData);
253         }
254 }
255
256 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
257 {
258         ModifierData *md = ob->modifiers.first;
259
260         for (; md; md = md->next) {
261                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
262
263                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
264                 else if (mti->foreachObjectLink) {
265                         /* each Object can masquerade as an ID, so this should be OK */
266                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
267                         mti->foreachObjectLink(md, ob, fp, userData);
268                 }
269         }
270 }
271
272 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
273 {
274         ModifierData *md = ob->modifiers.first;
275
276         for (; md; md = md->next) {
277                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
278
279                 if (mti->foreachTexLink)
280                         mti->foreachTexLink(md, ob, walk, userData);
281         }
282 }
283
284 /* callback's can use this
285  * to avoid copying every member.
286  */
287 void modifier_copyData_generic(const ModifierData *md_src, ModifierData *md_dst, const int UNUSED(flag))
288 {
289         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
290
291         /* md_dst may have already be fully initialized with some extra allocated data,
292          * we need to free it now to avoid memleak. */
293         if (mti->freeData) {
294                 mti->freeData(md_dst);
295         }
296
297         const size_t data_size = sizeof(ModifierData);
298         const char *md_src_data = ((const char *)md_src) + data_size;
299         char       *md_dst_data =       ((char *)md_dst) + data_size;
300         BLI_assert(data_size <= (size_t)mti->structSize);
301         memcpy(md_dst_data, md_src_data, (size_t)mti->structSize - data_size);
302 }
303
304 static void modifier_copy_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
305 {
306         ID *id = *idpoin;
307         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
308                 id_us_plus(id);
309         }
310 }
311
312 void modifier_copyData_ex(ModifierData *md, ModifierData *target, const int flag)
313 {
314         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
315
316         target->mode = md->mode;
317         target->flag = md->flag;
318
319         if (mti->copyData) {
320                 mti->copyData(md, target, flag);
321         }
322
323         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
324                 if (mti->foreachIDLink) {
325                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
326                 }
327                 else if (mti->foreachObjectLink) {
328                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
329                 }
330         }
331 }
332
333 void modifier_copyData(ModifierData *md, ModifierData *target)
334 {
335         modifier_copyData_ex(md, target, 0);
336 }
337
338
339 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
340 {
341         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
342
343         return ((!mti->isDisabled || !mti->isDisabled(scene, 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         return ((md->mode & eModifierMode_Realtime) &&
353                 (md->mode & eModifierMode_Editmode) &&
354                 (!mti->isDisabled || !mti->isDisabled(scene, md, 0)) &&
355                 modifier_supportsMapping(md));
356 }
357
358 bool modifier_isSameTopology(ModifierData *md)
359 {
360         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
361         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
362 }
363
364 bool modifier_isNonGeometrical(ModifierData *md)
365 {
366         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
367         return (mti->type == eModifierTypeType_NonGeometrical);
368 }
369
370 void modifier_setError(ModifierData *md, const char *_format, ...)
371 {
372         char buffer[512];
373         va_list ap;
374         const char *format = TIP_(_format);
375
376         va_start(ap, _format);
377         vsnprintf(buffer, sizeof(buffer), format, ap);
378         va_end(ap);
379         buffer[sizeof(buffer) - 1] = '\0';
380
381         if (md->error)
382                 MEM_freeN(md->error);
383
384         md->error = BLI_strdup(buffer);
385
386         CLOG_STR_ERROR(&LOG, md->error);
387 }
388
389 /* used for buttons, to find out if the 'draw deformed in editmode' option is
390  * there
391  *
392  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
393  * then is NULL)
394  * also used for some mesh tools to give warnings
395  */
396 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
397 {
398         VirtualModifierData virtualModifierData;
399         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
400         int i, cageIndex = -1;
401
402         if (r_lastPossibleCageIndex) {
403                 /* ensure the value is initialized */
404                 *r_lastPossibleCageIndex = -1;
405         }
406
407         /* Find the last modifier acting on the cage. */
408         for (i = 0; md; i++, md = md->next) {
409                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
410                 bool supports_mapping;
411
412                 if (mti->isDisabled && mti->isDisabled(scene, md, 0)) continue;
413                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
414                 if (md->mode & eModifierMode_DisableTemporary) continue;
415
416                 supports_mapping = modifier_supportsMapping(md);
417                 if (r_lastPossibleCageIndex && supports_mapping) {
418                         *r_lastPossibleCageIndex = i;
419                 }
420
421                 if (!(md->mode & eModifierMode_Realtime)) continue;
422                 if (!(md->mode & eModifierMode_Editmode)) continue;
423
424                 if (!supports_mapping)
425                         break;
426
427                 if (md->mode & eModifierMode_OnCage)
428                         cageIndex = i;
429         }
430
431         return cageIndex;
432 }
433
434
435 bool modifiers_isSoftbodyEnabled(Object *ob)
436 {
437         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
438
439         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
440 }
441
442 bool modifiers_isClothEnabled(Object *ob)
443 {
444         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
445
446         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
447 }
448
449 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
450 {
451         ModifierData *md = modifiers_findByType(ob, modifierType);
452
453         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
454 }
455
456 bool modifiers_isParticleEnabled(Object *ob)
457 {
458         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
459
460         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
461 }
462
463 /**
464  * Check whether is enabled.
465  *
466  * \param scene: Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
467  */
468 bool modifier_isEnabled(const struct Scene *scene, ModifierData *md, int required_mode)
469 {
470         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
471
472         if ((md->mode & required_mode) != required_mode) return false;
473         if (scene != NULL && mti->isDisabled && mti->isDisabled(scene, md, required_mode == eModifierMode_Render)) return false;
474         if (md->mode & eModifierMode_DisableTemporary) return false;
475         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
476
477         return true;
478 }
479
480 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
481                                     CustomDataMask dataMask, int required_mode,
482                                     ModifierData *previewmd, CustomDataMask previewmask)
483 {
484         CDMaskLink *dataMasks = NULL;
485         CDMaskLink *curr, *prev;
486
487         /* build a list of modifier data requirements in reverse order */
488         for (; md; md = md->next) {
489                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
490
491                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
492
493                 if (modifier_isEnabled(scene, md, required_mode)) {
494                         if (mti->requiredDataMask)
495                                 curr->mask = mti->requiredDataMask(ob, md);
496
497                         if (previewmd == md) {
498                                 curr->mask |= previewmask;
499                         }
500                 }
501
502                 /* prepend new datamask */
503                 curr->next = dataMasks;
504                 dataMasks = curr;
505         }
506
507         /* build the list of required data masks - each mask in the list must
508          * include all elements of the masks that follow it
509          *
510          * note the list is currently in reverse order, so "masks that follow it"
511          * actually means "masks that precede it" at the moment
512          */
513         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
514                 if (prev) {
515                         CustomDataMask prev_mask = prev->mask;
516                         CustomDataMask curr_mask = curr->mask;
517
518                         curr->mask = curr_mask | prev_mask;
519                 }
520                 else {
521                         CustomDataMask curr_mask = curr->mask;
522
523                         curr->mask = curr_mask | dataMask;
524                 }
525         }
526
527         /* reverse the list so it's in the correct order */
528         BLI_linklist_reverse((LinkNode **)&dataMasks);
529
530         return dataMasks;
531 }
532
533 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
534 {
535         ModifierData *tmp_md = NULL;
536
537         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
538                 return tmp_md;
539
540         /* Find the latest modifier in stack generating preview. */
541         for (; md; md = md->next) {
542                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
543                         tmp_md = md;
544         }
545         return tmp_md;
546 }
547
548 /* NOTE: This is to support old files from before Blender supported modifiers,
549  * in some cases versioning code updates these so for new files this will
550  * return an empty list. */
551 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
552 {
553         ModifierData *md;
554
555         md = ob->modifiers.first;
556
557         *virtualModifierData = virtualModifierCommonData;
558
559         if (ob->parent) {
560                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
561                         virtualModifierData->amd.object = ob->parent;
562                         virtualModifierData->amd.modifier.next = md;
563                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
564                         md = &virtualModifierData->amd.modifier;
565                 }
566                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
567                         virtualModifierData->cmd.object = ob->parent;
568                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
569                         virtualModifierData->cmd.modifier.next = md;
570                         md = &virtualModifierData->cmd.modifier;
571                 }
572                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
573                         virtualModifierData->lmd.object = ob->parent;
574                         virtualModifierData->lmd.modifier.next = md;
575                         md = &virtualModifierData->lmd.modifier;
576                 }
577         }
578
579         /* shape key modifier, not yet for curves */
580         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
581                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
582                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
583                 else
584                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
585
586                 virtualModifierData->smd.modifier.next = md;
587                 md = &virtualModifierData->smd.modifier;
588         }
589
590         return md;
591 }
592
593 /* Takes an object and returns its first selected armature, else just its armature
594  * This should work for multiple armatures per object
595  */
596 Object *modifiers_isDeformedByArmature(Object *ob)
597 {
598         VirtualModifierData virtualModifierData;
599         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
600         ArmatureModifierData *amd = NULL;
601
602         /* return the first selected armature, this lets us use multiple armatures */
603         for (; md; md = md->next) {
604                 if (md->type == eModifierType_Armature) {
605                         amd = (ArmatureModifierData *) md;
606                         if (amd->object && (amd->object->flag & SELECT))
607                                 return amd->object;
608                 }
609         }
610
611         if (amd) /* if were still here then return the last armature */
612                 return amd->object;
613
614         return NULL;
615 }
616
617 Object *modifiers_isDeformedByMeshDeform(Object *ob)
618 {
619         VirtualModifierData virtualModifierData;
620         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
621         MeshDeformModifierData *mdmd = NULL;
622
623         /* return the first selected armature, this lets us use multiple armatures */
624         for (; md; md = md->next) {
625                 if (md->type == eModifierType_MeshDeform) {
626                         mdmd = (MeshDeformModifierData *) md;
627                         if (mdmd->object && (mdmd->object->flag & SELECT))
628                                 return mdmd->object;
629                 }
630         }
631
632         if (mdmd) /* if were still here then return the last armature */
633                 return mdmd->object;
634
635         return NULL;
636 }
637
638 /* Takes an object and returns its first selected lattice, else just its lattice
639  * This should work for multiple lattices per object
640  */
641 Object *modifiers_isDeformedByLattice(Object *ob)
642 {
643         VirtualModifierData virtualModifierData;
644         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
645         LatticeModifierData *lmd = NULL;
646
647         /* return the first selected lattice, this lets us use multiple lattices */
648         for (; md; md = md->next) {
649                 if (md->type == eModifierType_Lattice) {
650                         lmd = (LatticeModifierData *) md;
651                         if (lmd->object && (lmd->object->flag & SELECT))
652                                 return lmd->object;
653                 }
654         }
655
656         if (lmd) /* if were still here then return the last lattice */
657                 return lmd->object;
658
659         return NULL;
660 }
661
662 /* Takes an object and returns its first selected curve, else just its curve
663  * This should work for multiple curves per object
664  */
665 Object *modifiers_isDeformedByCurve(Object *ob)
666 {
667         VirtualModifierData virtualModifierData;
668         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
669         CurveModifierData *cmd = NULL;
670
671         /* return the first selected curve, this lets us use multiple curves */
672         for (; md; md = md->next) {
673                 if (md->type == eModifierType_Curve) {
674                         cmd = (CurveModifierData *) md;
675                         if (cmd->object && (cmd->object->flag & SELECT))
676                                 return cmd->object;
677                 }
678         }
679
680         if (cmd) /* if were still here then return the last curve */
681                 return cmd->object;
682
683         return NULL;
684 }
685
686 bool modifiers_usesArmature(Object *ob, bArmature *arm)
687 {
688         VirtualModifierData virtualModifierData;
689         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
690
691         for (; md; md = md->next) {
692                 if (md->type == eModifierType_Armature) {
693                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
694                         if (amd->object && amd->object->data == arm)
695                                 return true;
696                 }
697         }
698
699         return false;
700 }
701
702 bool modifier_isCorrectableDeformed(ModifierData *md)
703 {
704         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
705         return mti->deformMatricesEM != NULL;
706 }
707
708 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
709 {
710         VirtualModifierData virtualModifierData;
711         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
712         int required_mode = eModifierMode_Realtime;
713
714         if (ob->mode == OB_MODE_EDIT) {
715                 required_mode |= eModifierMode_Editmode;
716         }
717         for (; md; md = md->next) {
718                 if (!modifier_isEnabled(scene, md, required_mode)) {
719                         /* pass */
720                 }
721                 else if (modifier_isCorrectableDeformed(md)) {
722                         return true;
723                 }
724         }
725         return false;
726 }
727
728 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
729  * to preview something... Used by DynamicPaint and WeightVG currently. */
730 bool modifiers_isPreview(Object *ob)
731 {
732         ModifierData *md = ob->modifiers.first;
733
734         for (; md; md = md->next) {
735                 if (modifier_isPreview(md))
736                         return true;
737         }
738
739         return false;
740 }
741
742 void modifier_freeTemporaryData(ModifierData *md)
743 {
744         if (md->type == eModifierType_Armature) {
745                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
746
747                 if (amd->prevCos) {
748                         MEM_freeN(amd->prevCos);
749                         amd->prevCos = NULL;
750                 }
751         }
752 }
753
754 /* ensure modifier correctness when changing ob->data */
755 void test_object_modifiers(Object *ob)
756 {
757         ModifierData *md;
758
759         /* just multires checked for now, since only multires
760          * modifies mesh data */
761
762         if (ob->type != OB_MESH) return;
763
764         for (md = ob->modifiers.first; md; md = md->next) {
765                 if (md->type == eModifierType_Multires) {
766                         MultiresModifierData *mmd = (MultiresModifierData *)md;
767
768                         multiresModifier_set_levels_from_disps(mmd, ob);
769                 }
770         }
771 }
772
773 /* where should this go?, it doesn't fit well anywhere :S - campbell */
774
775 /* elubie: changed this to default to the same dir as the render output
776  * to prevent saving to C:\ on Windows */
777
778 /* campbell: logic behind this...
779  *
780  * - if the ID is from a library, return library path
781  * - else if the file has been saved return the blend file path.
782  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
783  */
784 const char *modifier_path_relbase(Main *bmain, Object *ob)
785 {
786         if (G.relbase_valid || ID_IS_LINKED(ob)) {
787                 return ID_BLEND_PATH(bmain, &ob->id);
788         }
789         else {
790                 /* last resort, better then using "" which resolves to the current
791                  * working directory */
792                 return BKE_tempdir_session();
793         }
794 }
795
796 const char *modifier_path_relbase_from_global(Object *ob)
797 {
798         if (G.relbase_valid || ID_IS_LINKED(ob)) {
799                 return ID_BLEND_PATH_FROM_GLOBAL(&ob->id);
800         }
801         else {
802                 /* last resort, better then using "" which resolves to the current
803                  * working directory */
804                 return BKE_tempdir_session();
805         }
806 }
807
808 /* initializes the path with either */
809 void modifier_path_init(char *path, int path_maxlen, const char *name)
810 {
811         /* elubie: changed this to default to the same dir as the render output
812          * to prevent saving to C:\ on Windows */
813         BLI_join_dirfile(path, path_maxlen,
814                          G.relbase_valid ? "//" : BKE_tempdir_session(),
815                          name);
816 }
817
818
819 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
820
821 struct Mesh *modwrap_applyModifier(
822         ModifierData *md, const ModifierEvalContext *ctx,
823         struct Mesh *me)
824 {
825         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
826         BLI_assert(CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
827
828         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
829                 BKE_mesh_calc_normals(me);
830         }
831         return mti->applyModifier(md, ctx, me);
832 }
833
834 void modwrap_deformVerts(
835         ModifierData *md, const ModifierEvalContext *ctx,
836         Mesh *me, float (*vertexCos)[3], int numVerts)
837 {
838         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
839         BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
840
841         if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
842                 BKE_mesh_calc_normals(me);
843         }
844         mti->deformVerts(md, ctx, me, vertexCos, numVerts);
845 }
846
847 void modwrap_deformVertsEM(
848         ModifierData *md, const ModifierEvalContext *ctx,
849         struct BMEditMesh *em, Mesh *me,
850         float (*vertexCos)[3], int numVerts)
851 {
852         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
853         BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
854
855         if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
856                 BKE_mesh_calc_normals(me);
857         }
858         mti->deformVertsEM(md, ctx, em, me, vertexCos, numVerts);
859 }
860
861 /* end modifier callback wrappers */
862
863
864 /* wrappers for modifier callbacks that accept Mesh and select the proper implementation
865  * depending on if the modifier has been ported to Mesh or is still using DerivedMesh
866  */
867
868 /* deprecated variants of above that accept DerivedMesh */
869
870 struct DerivedMesh *modifier_applyModifier_DM_deprecated(
871         struct ModifierData *md, const ModifierEvalContext *ctx,
872         struct DerivedMesh *dm)
873 {
874         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
875
876         /* TODO(sybren): deduplicate all the copies of this code in this file. */
877         Mesh *mesh = NULL;
878         if (dm != NULL) {
879                 mesh = BKE_id_new_nomain(ID_ME, NULL);
880                 DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
881         }
882
883         struct Mesh *new_mesh = mti->applyModifier(md, ctx, mesh);
884
885         /* Make a DM that doesn't reference new_mesh so we can free the latter. */
886         DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE, CD_MASK_EVERYTHING);
887
888         if (new_mesh != mesh) {
889                 BKE_id_free(NULL, new_mesh);
890         }
891         if (mesh != NULL) {
892                 BKE_id_free(NULL, mesh);
893         }
894
895         return ndm;
896
897 }
898
899 /**
900  * Get evaluated mesh for other evaluated object, which is used as an operand for the modifier,
901  * e.g. second operand for boolean modifier.
902  * Note that modifiers in stack always get fully evaluated COW ID pointers, never original ones. Makes things simpler.
903  *
904  * \param get_cage_mesh Return evaluated mesh with only deforming modifiers applied
905  *                      (i.e. mesh topology remains the same as original one, a.k.a. 'cage' mesh).
906  */
907 Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval, const bool get_cage_mesh)
908 {
909         Mesh *me = NULL;
910
911         if ((ob_eval->type == OB_MESH) && (ob_eval->mode & OB_MODE_EDIT)) {
912                 /* In EditMode, evaluated mesh is stored in BMEditMesh, not the object... */
913                 BMEditMesh *em = BKE_editmesh_from_object(ob_eval);
914                 if (em != NULL) {  /* em might not exist yet in some cases, just after loading a .blend file, see T57878. */
915                         me = (get_cage_mesh && em->mesh_eval_cage != NULL) ? em->mesh_eval_cage : em->mesh_eval_final;
916                 }
917         }
918         if (me == NULL) {
919                 me = (get_cage_mesh && ob_eval->runtime.mesh_deform_eval != NULL) ? ob_eval->runtime.mesh_deform_eval :
920                                                                                     ob_eval->runtime.mesh_eval;
921         }
922
923         return me;
924 }