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