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