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